Mapa das cidades
Conheça as cidades que fazem parte do LUPPA e suas agendas alimentares urbanas.
{"map_options":{"center_lat":"-1.946362385338624","center_lng":"-54.737774737736956","zoom":5,"map_type_id":"ROADMAP","center_by_nearest":false,"fit_bounds":true,"center_circle_fillcolor":"#8CAEF2","center_circle_fillopacity":".5","center_circle_strokecolor":"#8CAEF2","center_circle_strokeopacity":".5","show_center_circle":false,"show_center_marker":false,"center_marker_icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images//default_marker.png","draggable":true,"scroll_wheel":"false","gesture":"auto","marker_default_icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","infowindow_setting":"<div>{marker_title}</div>\n<div>{marker_address}</div>\n","infowindow_geotags_setting":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\n{post_title} <span class=\"fc-badge info\">{post_categories}</span></div>\r\n {post_excerpt}\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"{post_link}\">Ver mais</a></p></div>","infowindow_skin":{"name":"default","type":"infowindow","sourcecode":"&lt;div&gt;{marker_title}&lt;/div&gt;&lt;div&gt;{marker_address}&lt;/div&gt;"},"infowindow_post_skin":{"name":"default","type":"post","sourcecode":"&lt;div class=&quot;fc-main&quot;&gt;\r\n&lt;div class=&quot;fc-item-title&quot;&gt;\r\n{post_title} &lt;span class=&quot;fc-badge info&quot;&gt;{post_categories}&lt;/span&gt;&lt;/div&gt;\r\n {post_excerpt}\r\n&lt;p&gt;&lt;a target=&quot;_blank&quot; class=&quot;fc-btn fc-btn-small fc-btn-luppa&quot; href=&quot;{post_link}&quot;&gt;Ver mais&lt;/a&gt;&lt;/p&gt;&lt;/div&gt;"},"infowindow_drop_animation":false,"close_infowindow_on_map_click":true,"default_infowindow_open":false,"infowindow_open_event":"click","infowindow_filter_only":false,"infowindow_click_change_zoom":0,"infowindow_click_change_center":false,"full_screen_control":true,"search_control":true,"zoom_control":true,"map_type_control":true,"street_view_control":true,"locateme_control":false,"mobile_specific":false,"zoom_mobile":5,"draggable_mobile":true,"scroll_wheel_mobile":true,"full_screen_control_position":"TOP_LEFT","search_control_position":"TOP_LEFT","locateme_control_position":"TOP_LEFT","zoom_control_position":"TOP_LEFT","map_type_control_position":"TOP_LEFT","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,"search_placeholder":"Pesquise pela cidade","select_category":"Selecione o Subtema","bound_map_after_filter":false,"display_reset_button":false,"map_reset_button_text":"Reset","height":"450"},"places":[{"source":"post","title":"Alenquer","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nAlenquer <span class=\"fc-badge info\"></span></div>\r\n Par\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/alenquer-2/\">Ver mais</a></p></div>","content":"Par\u00e1, Brasil","location":{"lat":"-1.946362385338624","lng":"-54.737774737736956","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/alenquer-2/","zoom":5,"extra_fields":{"post_excerpt":"Par\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p><span>69.377</span>\u00a0habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p><span>23.645</span>\u00a0km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://alenquer.pa.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/pa/alenquer.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivos fiscais\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-incentivo\" _builder_version=\"4.25.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#refrigerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"871\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pagamentos por Servi\u00e7os Ambientais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pagamentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"782\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivos fiscais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"601\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Incentivo Fiscal</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui <strong>LOSAN.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2021</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2023</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p><strong>Acima de 18 anos: 20,82% de obesidade e 33,9% de sobrepeso. </strong></p>\n<p><strong>Entre 13 e 17 anos: 6,67% de obesidade e 24,76% de sobrepeso. </strong></p>\n<p><strong>Entre 10 e 12 anos: 4,28% de obesidade e 12,4% de sobrepeso. </strong></p>\n<p><strong>Entre 2 e 4 anos: 1% de obesidade.</strong></p>\n<p><strong> Abaixo de 2 anos: 10% de obesidade.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||2px|||\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>3</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio existem feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o\u00a0<strong>festival da galinha caipira, do peixe acari, camar\u00e3o, tucunar\u00e9, festival do a\u00e7a\u00ed e demais que s\u00e3o realizados anualmente. </strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio tem mapeamento de produtores familiares feito no ano <strong>2023</strong>. S\u00e3o 150 produtores que produzem principalmente <strong>farinha de mandioca, peixes, galinha caipira, frutas, verduras , hortali\u00e7as, cumaru, castanha do Par\u00e1 bovinos e su\u00ednos.</strong> </p>\n<p>Destes, <strong>150 possuem DAP</strong> - Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente<strong> 22 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico/org\u00e2nico</strong>.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias. O principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio </span><span>fornece <strong>mudas agroecol\u00f3gicas/org\u00e2nicas</strong></span><span> e possui </span><span>programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas</span><span>.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>12.733\u00a0mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #refrigerantes\" module_id=\"refrigerantes\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"refrigerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"874\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui lei/decreto que proibe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa <strong>30%</strong> do or\u00e7amento recebido pelo PNAE e <strong>menos da metade</strong> vem da produ\u00e7\u00e3o local. <br /></span><span>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica). <br />No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pagamentos\" module_id=\"pagamentos\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pagamentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"795\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui programa de compostagem relacionada \u00e0 <strong>coleta de res\u00edduo org\u00e2nico </strong></span><span>e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>duas ou mais vezes por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivos\" module_id=\"incentivos\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui o <strong>IPTU verde</strong>, que \u00e9 um tipo de incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"707\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>INCENTIVO FISCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Alenquer","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/alenquer-2/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alenquer\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/05/Mapa-Alenquer-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1723234461:384","%_last_editor_used_jetpack%":"block-editor","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-1.946362385338624","%_wpgmp_metabox_longitude%":"-54.737774737736956","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:25:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"7\";i:3;s:2:\"12\";i:4;s:2:\"15\";i:5;s:2:\"19\";i:6;s:2:\"20\";i:7;s:2:\"22\";i:8;s:2:\"23\";i:9;s:2:\"25\";i:10;s:2:\"26\";i:11;s:2:\"28\";i:12;s:2:\"29\";i:13;s:2:\"30\";i:14;s:2:\"31\";i:15;s:2:\"33\";i:16;s:2:\"34\";i:17;s:2:\"37\";i:18;s:2:\"38\";i:19;s:2:\"41\";i:20;s:2:\"44\";i:21;s:2:\"45\";i:22;s:2:\"46\";i:23;s:2:\"47\";i:24;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_focuskw%":"Alenquer","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de Alenquer cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticasP\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_linkdex%":"64","%_yoast_wpseo_estimated-reading-time-minutes%":"12","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"3508\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3699","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Alenquer</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Alenquer</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_populacao\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">69.377\u00a0habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_quadro\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">23.645\u00a0km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_pin\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-uma-linha botao-filtros-cidades df-button dfc-incentivo et_pb_bg_layout_light\" href=\"\">Incentivos fiscais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=200%2C200&#038;ssl=1\" alt=\"Losan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=200%2C201&#038;ssl=1\" alt=\"Comsea\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=200%2C201&#038;ssl=1\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=200%2C201&#038;ssl=1\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?resize=200%2C201&#038;ssl=1\" alt=\"Banco de alimentos municipal\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras convencionais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=200%2C201&#038;ssl=1\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=200%2C201&#038;ssl=1\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png?resize=200%2C200&#038;ssl=1\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=200%2C200&#038;ssl=1\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas escolares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png?resize=200%2C200&#038;ssl=1\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png?resize=200%2C200&#038;ssl=1\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=200%2C201&#038;ssl=1\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png?resize=200%2C200&#038;ssl=1\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-460\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de refrigerante nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=200%2C201&#038;ssl=1\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_8 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_23 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=200%2C201&#038;ssl=1\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_24 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png?resize=200%2C201&#038;ssl=1\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-485\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pagamentos por Servi\u00e7os Ambientais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_25 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?resize=200%2C201&#038;ssl=1\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_26 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=200%2C201&#038;ssl=1\" alt=\"Controle de desmatamento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_27 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de compostagem\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_28 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=200%2C201&#038;ssl=1\" alt=\"Coleta seletiva\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_9 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_29 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png?resize=200%2C200&#038;ssl=1\" alt=\"Incentivos fiscais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-479\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivos fiscais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Incentivo Fiscal</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_30 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_31 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_32 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_33 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2021, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: 20,82% de obesidade e 33,9% de sobrepeso.<br />\nEntre 13 e 17 anos: 6,67% de obesidade e 24,76% de sobrepeso.<br />\nEntre 10 e 12 anos: 4,28% de obesidade e 12,4% de sobrepeso.<br />\nEntre 2 e 4 anos: 1% de obesidade.<br />\n Abaixo de 2 anos: 10% de obesidade.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 3 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existem feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_42  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o\u00a0festival da galinha caipira, do peixe acari, camar\u00e3o, tucunar\u00e9, festival do a\u00e7a\u00ed e demais que s\u00e3o realizados anualmente. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares feito no ano 2023. S\u00e3o 150 produtores que produzem principalmente farinha de mandioca, peixes, galinha caipira, frutas, verduras , hortali\u00e7as, cumaru, castanha do Par\u00e1 bovinos e su\u00ednos.<br />\nDestes, 150 possuem DAP &#8211; Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 22 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias. O principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas e possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 12.733\u00a0mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"refrigerantes\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_51  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que proibe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_52  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_53  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa 30% do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local. As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica). No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pagamentos\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_55  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_56  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_26 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_32\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_57  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_27 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_58  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada duas ou mais vezes por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivos\" class=\"et_pb_section et_pb_section_28 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_34\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_59  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui o IPTU verde, que \u00e9 um tipo de incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>INCENTIVO FISCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2024-09-01 11:14:29","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_wp_page_template%":"default","%_yoast_wpseo_content_score%":"30","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Incentivo Fiscal, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":3508,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Incentivo Fiscal","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de refrigerantes nas escolas","id":"34","type":"category","extension_fields":{"cat_order":"31"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]},{"source":"post","title":"Arauc\u00e1ria","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nArauc\u00e1ria <span class=\"fc-badge info\"></span></div>\r\n Paran\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/araucaria/\">Ver mais</a></p></div>","content":"Paran\u00e1, Brasil","location":{"lat":"-25.590063569605313","lng":"-49.400779792808365","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/araucaria/","zoom":5,"extra_fields":{"post_excerpt":"Paran\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p><span>151.666</span> habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p><span>469,240</span> km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://araucaria.atende.net/cidadao\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/pr/araucaria.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"1px||1px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Frente Parlamentar de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#frente\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"558\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.3\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2021</strong>.</p>\n<p><strong>LEI N\u00ba 3674, de 2021.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2016</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2022</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2023</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias: <strong>Secretaria Municipal de Assist\u00eancia Social, Secretaria Municipal de Sa\u00fade, Secretaria Municipal de Esporte e Lazer, Secretaria Municipal de Agricultura, Secretaria Municipal de Educa\u00e7\u00e3o e Secretaria Municipal de Meio Ambiente</strong>.<br />A presid\u00eancia \u00e9 exercida pela <strong>secretaria Municipal de Assist\u00eancia Social. </strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #frente\" module_id=\"frente\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"frente\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"667\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Frente Parlamentar de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a0<strong>2016</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio formulou <strong>plano municipal de SAN</strong>, cuja vers\u00e3o mais atual \u00e9 do ano de <strong>2024</strong>. </span><span>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p><strong>Acima de 18 anos: 33,36% de obesidade e 33,46% de sobrepeso. </strong></p>\n<p><strong>Entre 13 e 17 anos: 15,7% de obesidade e 18,99% de sobrepeso. </strong></p>\n<p><strong>Entre 10 e 12 anos: 18,8% de obesidade e 21,21% de sobrepeso.</strong></p>\n<p><strong>Entre 4 e 9 anos: 15,99% de obesidade e 18,41% de sobrepeso.</strong></p>\n<p><strong>Entre 2 e 4 anos: 4,61% de obesidade e 8,3% de sobrepeso.</strong></p>\n<p><strong> Abaixo de 2 anos: 2,51% de obesidade e 7,18% de sobrepeso. </strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio criou</span><span> </span><span>programa de transfer\u00eancia de renda.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerantes\" module_id=\"itinerantes\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>No munic\u00edpio funcionam feiras itinerantes </span><span>com comercializa\u00e7\u00e3o de alimentos<strong> agroecol\u00f3gicos/org\u00e2nicos</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio realiza eventos gastron\u00f4micos anualmene.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio tem mapeamento de produtores familiares. S\u00e3o agricultores que produzem principalmente <strong>trigo, soja, milho, feij\u00e3o e oler\u00edcolas</strong>. Destes, <strong>1550</strong> possuem DAP - Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares. O principal modelo de produ\u00e7\u00e3o \u00e9 a <strong>convencional.</strong></p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias. O principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional.</strong></p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>3500\u00a0mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e<span>\u00a0em desperd\u00edcio e aproveitamento integral dos alimentos.</span></strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa<strong> mais de 50%</strong> do or\u00e7amento recebido pelo PNAE e <strong>mais da metade</strong> da compra direta da AF vem da produ\u00e7\u00e3o local. </span></p>\n<p><span>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica). </span></p>\n<p><span>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>duas ou mais vezes por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Arauc\u00e1ria","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/araucaria/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Arauc\u00e1ria\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/05/Mapa-Araucaria-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1716576870:7","%_last_editor_used_jetpack%":"block-editor","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-25.590063569605313","%_wpgmp_metabox_longitude%":"-49.400779792808365","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:22:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:1:\"9\";i:6;s:2:\"10\";i:7;s:2:\"11\";i:8;s:2:\"12\";i:9;s:2:\"18\";i:10;s:2:\"21\";i:11;s:2:\"23\";i:12;s:2:\"25\";i:13;s:2:\"26\";i:14;s:2:\"27\";i:15;s:2:\"28\";i:16;s:2:\"29\";i:17;s:2:\"33\";i:18;s:2:\"37\";i:19;s:2:\"38\";i:20;s:2:\"45\";i:21;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_focuskw%":"Arauc\u00e1ria","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de Arauc\u00e1ria cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticasP\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_estimated-reading-time-minutes%":"10","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"3505\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3706","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_29 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_60  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Arauc\u00e1ria</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_30 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_61   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Arauc\u00e1ria</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_populacao\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">151.666 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_quadro\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">469,240 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_pin\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_92 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_93 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_62    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_31 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_38 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_63  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_39 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_64  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_13_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_13 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_14_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_14 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_32 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_65 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=200%2C200&#038;ssl=1\" alt=\"Losan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_66 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=200%2C201&#038;ssl=1\" alt=\"Comsea\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_67 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=200%2C201&#038;ssl=1\" alt=\"Sisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_68 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=200%2C201&#038;ssl=1\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_69 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=200%2C201&#038;ssl=1\" alt=\"Caisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_70 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?resize=200%2C201&#038;ssl=1\" alt=\"Frente Parlamentar de SAN\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-456\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Frente Parlamentar de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_41 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_71 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?resize=200%2C201&#038;ssl=1\" alt=\"Plano de SAN\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_72 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=200%2C201&#038;ssl=1\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_73 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_74 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png?resize=200%2C200&#038;ssl=1\" alt=\"Feira itinerante\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_75 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=200%2C201&#038;ssl=1\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_76 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png?resize=200%2C200&#038;ssl=1\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_42 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_77 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=200%2C200&#038;ssl=1\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_78 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?resize=200%2C201&#038;ssl=1\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_79 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas escolares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_80 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_81 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=200%2C201&#038;ssl=1\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_82 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=200%2C201&#038;ssl=1\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_43 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_83 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_43 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=200%2C201&#038;ssl=1\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_84 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_44 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=200%2C201&#038;ssl=1\" alt=\"Controle de desmatamento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_85 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_45 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=200%2C201&#038;ssl=1\" alt=\"Coleta seletiva\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_86 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_87 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_88 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_33 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_44\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_89  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2021.<br />\nLEI N\u00ba 3674, de 2021.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_34 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_45\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_90  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2016, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_35 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_46\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_91  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02022.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_92  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_93  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias: Secretaria Municipal de Assist\u00eancia Social, Secretaria Municipal de Sa\u00fade, Secretaria Municipal de Esporte e Lazer, Secretaria Municipal de Agricultura, Secretaria Municipal de Educa\u00e7\u00e3o e Secretaria Municipal de Meio Ambiente.A presid\u00eancia \u00e9 exercida pela secretaria Municipal de Assist\u00eancia Social. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"frente\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_94  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Frente Parlamentar de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a02016.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_50\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_95  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de 2024. Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_96  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: 33,36% de obesidade e 33,46% de sobrepeso.<br />\nEntre 13 e 17 anos: 15,7% de obesidade e 18,99% de sobrepeso.<br />\nEntre 10 e 12 anos: 18,8% de obesidade e 21,21% de sobrepeso.<br />\nEntre 4 e 9 anos: 15,99% de obesidade e 18,41% de sobrepeso.<br />\nEntre 2 e 4 anos: 4,61% de obesidade e 8,3% de sobrepeso.<br />\n Abaixo de 2 anos: 2,51% de obesidade e 7,18% de sobrepeso. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_41 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_52\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_97  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerantes\" class=\"et_pb_section et_pb_section_42 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_98  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_43 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_54\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_99  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_126  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos anualmene.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_44 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_100  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares. S\u00e3o agricultores que produzem principalmente trigo, soja, milho, feij\u00e3o e oler\u00edcolas. Destes, 1550 possuem DAP &#8211; Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_56\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_101  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_57\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_102  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_47 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_103  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares. O principal modelo de produ\u00e7\u00e3o \u00e9 a convencional.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_48 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_59\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_104  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias. O principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_49 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_60\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_105  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_144  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 3500\u00a0mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_145  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_50 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_61\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_106  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_146  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e\u00a0em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_51 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_62\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_107  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_149  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_150  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de 50% do or\u00e7amento recebido pelo PNAE e mais da metade da compra direta da AF vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_151  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_52 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_63\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_108  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_152  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_153  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_154  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_53 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_64\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_109  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_155  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_156  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada duas ou mais vezes por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_157  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2024-09-01 11:14:30","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_wp_page_template%":"default","%_yoast_wpseo_content_score%":"30","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":3505,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Frente Parlamentar de SAN","id":"9","type":"category","extension_fields":{"cat_order":"6"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pactos internacionais","id":"11","type":"category","extension_fields":{"cat_order":"8"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Itaja\u00ed","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nItaja\u00ed <span class=\"fc-badge info\"></span></div>\r\n Santa Catarina, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/itajai/\">Ver mais</a></p></div>","content":"Santa Catarina, Brasil","location":{"lat":"-26.906841927392442","lng":"-48.6813295998756","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/itajai/","zoom":5,"extra_fields":{"post_excerpt":"Santa Catarina, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p><span>264.054 </span>habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p><span>289,215</span>\u00a0km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://itajai.sc.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/sc/itajai.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.3\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.0\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.25.0\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui LOSAN desde <strong>2003</strong>. Lei Municipal n\u00ba 6.953 de 16/10/2018 (Lei de SAN de Itaja\u00ed); Lei Municipal n\u00ba 6.902 de 12/06/2018 (Institui\u00e7\u00e3o da CAISAN); Lei n\u00ba 3.990 de 30/10/2003 (Institui\u00e7\u00e3o do COMSEA).</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2003</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2023</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta <span> pelos mesmos membros governamentais do COMSEA, sendo os representantes das <strong>Secretarias de Assist\u00eancia Social, Agricultura e Expans\u00e3o Urbana, Sa\u00fade, Educa\u00e7\u00e3o e Desenvolvimento Econ\u00f4mico. Al\u00e9m dessas 5 Secretarias, que possuem direito a voz e ao voto, outros 7 \u00f3rg\u00e3os/autarquias participam como membros convidados permanentes, com direito \u00e0 voz e n\u00e3o ao voto, sendo os seguintes: Instituto Itaja\u00ed Sustent\u00e1vel (Meio Ambiente), SEMASA (Servi\u00e7o Municipal de \u00c1gua, Saneamento e Infraestrutra), Vigil\u00e2ncia Sanit\u00e1ria, Vigil\u00e2ncia Epidemiol\u00f3gica, Funda\u00e7\u00e3o Municipal de Esportes e Lazer, Secretaria de Promo\u00e7\u00e3o da Cidadania e Secretaria de Desenvolvimento Urbano e Habita\u00e7\u00e3o.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de <strong>2022 a 2025</strong>. </span></p>\n<p><span>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p><strong>Acima de 18 anos: 39,09% de obesidade e 38,64% de sobrepeso. </strong></p>\n<p><strong>Entre 13 e 17 anos: 13,04% de obesidade e 19,26% de sobrepeso.</strong></p>\n<p><strong>Entre 10 e 12 anos: 16,62% de obesidade e 20,85% de sobrepeso.</strong></p>\n<p><strong>Entre 5 e 9 anos: 14,44% de obesidade e 16,72% de sobrepeso. </strong></p>\n<p><strong>Entre 2 e 4 anos: 3,73% de obesidade e 6,62% de sobrepeso.</strong></p>\n<p><strong> Abaixo de 2 anos: 2,93% de obesidade e 8,03% de sobrepeso. </strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio criou</span><span> programa de transfer\u00eancia de renda</span><span> no valor de <strong>R$ 150,00</strong> por m\u00eas e atende um total aproximado de <strong>600</strong> beneficiados.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existe<strong> 1</strong> feira convencional funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerantes\" module_id=\"itinerantes\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existe<strong> 1</strong> feira itinerante funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos <strong>agroecol\u00f3gicos ou org\u00e2nicos. </strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como a <strong>Festa do Peixe, Festa do Colono e Marejada (Festa Portuguesa e do Pescado) que ocorrem anualmente. </strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente<strong> 11\u00a0escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico/org\u00e2nico</strong>.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.\u00a0</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>32 a 39 mil\u00a0refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em</span><strong> alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa <strong>mais de 50%</strong> do or\u00e7amento recebido pelo PNAE e <strong>mais da metade</strong> da compra direta da AF vem da produ\u00e7\u00e3o local. </span></p>\n<p><span>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>1 vez\u00a0por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Itaja\u00ed","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/itajai/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Itaja\u00ed\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/05/Imagens-noticiasbiblioteca-LUPPA-1-1-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1716577767:7","%_last_editor_used_jetpack%":"block-editor","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-26.906841927392442","%_wpgmp_metabox_longitude%":"-48.6813295998756","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:24:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"12\";i:7;s:2:\"14\";i:8;s:2:\"18\";i:9;s:2:\"19\";i:10;s:2:\"20\";i:11;s:2:\"21\";i:12;s:2:\"22\";i:13;s:2:\"23\";i:14;s:2:\"26\";i:15;s:2:\"27\";i:16;s:2:\"28\";i:17;s:2:\"29\";i:18;s:2:\"30\";i:19;s:2:\"33\";i:20;s:2:\"37\";i:21;s:2:\"38\";i:22;s:2:\"45\";i:23;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_focuskw%":"Itaja\u00ed","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de Itaja\u00ed cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticasP\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_estimated-reading-time-minutes%":"11","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"3502\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3712","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_54 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_66\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_110  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_158  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_159  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Itaja\u00ed</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_55 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_111   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_16 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_2 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Itaja\u00ed</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_160  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_11 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_8\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_populacao\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_18 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_161  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">264.054 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_12 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_quadro\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_20 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_162  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">289,215\u00a0km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_13 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_21\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_10\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_pin\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_22 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_163  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_14 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_23 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_164  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_165 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_166 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_112    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_56 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_68 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_113  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_167  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_69 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_114  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_15_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_15 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_16_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_16 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_17_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_17 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_18_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_18 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_19_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_19 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_20_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_20 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_21_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_21 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_57 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_70 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_115 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_46 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=200%2C200&#038;ssl=1\" alt=\"Losan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_116 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_47 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=200%2C201&#038;ssl=1\" alt=\"Comsea\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_117 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_48 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=200%2C201&#038;ssl=1\" alt=\"Sisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_118 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_49 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=200%2C201&#038;ssl=1\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_119 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_50 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=200%2C201&#038;ssl=1\" alt=\"Caisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_120 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_51 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?resize=200%2C201&#038;ssl=1\" alt=\"Plano de SAN\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_71 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_121 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_52 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=200%2C201&#038;ssl=1\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_122 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_53 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_123 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_54 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_124 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_55 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras convencionais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_125 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_56 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png?resize=200%2C200&#038;ssl=1\" alt=\"Feira itinerante\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_126 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_57 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=200%2C201&#038;ssl=1\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_72 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_127 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_58 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=200%2C201&#038;ssl=1\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_128 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_59 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=200%2C200&#038;ssl=1\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_129 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_60 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?resize=200%2C201&#038;ssl=1\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_130 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_61 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas escolares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_131 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_62 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_132 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_63 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png?resize=200%2C200&#038;ssl=1\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_73 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_133 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_64 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=200%2C201&#038;ssl=1\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_134 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_65 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=200%2C201&#038;ssl=1\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_135 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_66 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=200%2C201&#038;ssl=1\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_136 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_67 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=200%2C201&#038;ssl=1\" alt=\"Controle de desmatamento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_137 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_68 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=200%2C201&#038;ssl=1\" alt=\"Coleta seletiva\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_138 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_58 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_74\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_139  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_168  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_169  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2003. Lei Municipal n\u00ba 6.953 de 16/10/2018 (Lei de SAN de Itaja\u00ed); Lei Municipal n\u00ba 6.902 de 12/06/2018 (Institui\u00e7\u00e3o da CAISAN); Lei n\u00ba 3.990 de 30/10/2003 (Institui\u00e7\u00e3o do COMSEA).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_170  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_59 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_75\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_140  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_171  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_172  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2003, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_173  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_60 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_76\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_141  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_174  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_175  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_176  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_61 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_77\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_142  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_177  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_178  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_179  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_62 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_78\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_143  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_180  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_181  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta  pelos mesmos membros governamentais do COMSEA, sendo os representantes das Secretarias de Assist\u00eancia Social, Agricultura e Expans\u00e3o Urbana, Sa\u00fade, Educa\u00e7\u00e3o e Desenvolvimento Econ\u00f4mico. Al\u00e9m dessas 5 Secretarias, que possuem direito a voz e ao voto, outros 7 \u00f3rg\u00e3os/autarquias participam como membros convidados permanentes, com direito \u00e0 voz e n\u00e3o ao voto, sendo os seguintes: Instituto Itaja\u00ed Sustent\u00e1vel (Meio Ambiente), SEMASA (Servi\u00e7o Municipal de \u00c1gua, Saneamento e Infraestrutra), Vigil\u00e2ncia Sanit\u00e1ria, Vigil\u00e2ncia Epidemiol\u00f3gica, Funda\u00e7\u00e3o Municipal de Esportes e Lazer, Secretaria de Promo\u00e7\u00e3o da Cidadania e Secretaria de Desenvolvimento Urbano e Habita\u00e7\u00e3o.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_182  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_63 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_79\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_144  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_183  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_184  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de 2022 a 2025.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_185  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_64 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_80\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_145  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_186  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_187  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: 39,09% de obesidade e 38,64% de sobrepeso.<br />\nEntre 13 e 17 anos: 13,04% de obesidade e 19,26% de sobrepeso.<br />\nEntre 10 e 12 anos: 16,62% de obesidade e 20,85% de sobrepeso.<br />\nEntre 5 e 9 anos: 14,44% de obesidade e 16,72% de sobrepeso.<br />\nEntre 2 e 4 anos: 3,73% de obesidade e 6,62% de sobrepeso.<br />\n Abaixo de 2 anos: 2,93% de obesidade e 8,03% de sobrepeso. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_188  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_65 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_81\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_146  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_189  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_190  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 150,00 por m\u00eas e atende um total aproximado de 600 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_191  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_66 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_82\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_147  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_192  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_193  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_194  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_67 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_83\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_148  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_195  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_196  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existe 1 feira convencional funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_197  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerantes\" class=\"et_pb_section et_pb_section_68 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_84\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_149  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_198  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_199  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existe 1 feira itinerante funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_200  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_69 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_85\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_150  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_201  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_202  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_203  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_70 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_86\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_151  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_204  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_205  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como a Festa do Peixe, Festa do Colono e Marejada (Festa Portuguesa e do Pescado) que ocorrem anualmente. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_206  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_71 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_87\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_152  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_207  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_208  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_209  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_72 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_88\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_153  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_210  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_211  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_212  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_73 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_89\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_154  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_213  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_214  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 11\u00a0escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_215  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_74 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_90\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_155  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_216  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_217  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.\u00a0</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_218  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_75 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_91\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_156  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_219  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_220  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_221  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_76 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_92\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_157  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_222  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_223  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 32 a 39 mil\u00a0refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_224  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_77 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_93\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_158  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_225  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_226  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_227  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_78 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_94\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_159  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_228  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_229  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de 50% do or\u00e7amento recebido pelo PNAE e mais da metade da compra direta da AF vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_230  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_79 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_95\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_160  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_231  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_232  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_233  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_80 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_96\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_161  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_234  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_235  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada 1 vez\u00a0por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_236  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2024-09-01 11:14:31","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_wp_page_template%":"default","%_yoast_wpseo_content_score%":"30","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Subtropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":3502,"custom_filters":{"%regiao%":["Centro-Sul | Subtropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Caxias do Sul","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nCaxias do Sul <span class=\"fc-badge info\"></span></div>\r\n Rio Grande do Sul, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/caxias-do-sul/\">Ver mais</a></p></div>","content":"Rio Grande do Sul, Brasil","location":{"lat":"-29.17477689916077","lng":"-51.18886207138418","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/caxias-do-sul/","zoom":5,"extra_fields":{"post_excerpt":"Rio Grande do Sul, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>463.501 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.652 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.caxias.rs.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/rs/caxias-do-sul.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Frente Parlamentar de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#frente\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"558\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Cozinha comunit\u00e1ria\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#cozinha\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"775\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#refrigerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"871\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#ultraprocesssados\" hover_enabled=\"0\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"872\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\" sticky_enabled=\"0\"]<p>Alimenta\u00e7\u00e3o Escolar</p>[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2012</strong>.</p>\n<p><strong>LEI N\u00ba 7241, de 26/03/2012.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2003</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2012</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2022</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os:<strong> Secretaria Municipal de Agricultura Pecu\u00e1ria e Abastecimento, Funda\u00e7\u00e3o de Assist\u00eancia Social, Secretaria Municipal de Sa\u00fade, Secretaria Municipal de Educa\u00e7\u00e3o, Secretaria Municipal de Desenvolvimento Econ\u00f4mico e Inova\u00e7\u00e3o, Secretaria Municipal de Meio Ambiente e Secretaria Municipal de Seguran\u00e7a P\u00fablica e Prote\u00e7\u00e3o Social. </strong></p>\n<p>A presid\u00eancia \u00e9 exercida pela <strong>Secretaria Municipal de Agricultura Pecu\u00e1ria e Abastecimento.</strong></p>\n<div id=\"docs-chrome\" role=\"banner\" aria-label=\"Barra de menus\" class=\"docs-material companion-enabled\" tabindex=\"0\">\n<div id=\"docs-additional-bars\">\n<div id=\"formula-bar-dragger\" class=\"formula-bar-hoverable\"></div>\n<div id=\"waffle-editorsized-bar\">\n<div id=\"waffle-db-delegation-banner-id\"></div>\n<div id=\"waffle-dbsource-configbar-id\"></div>\n<div id=\"waffle-filterbar-id\"></div>\n</div>\n</div>\n<div id=\"docs-transient-bar-container\"></div>\n<div id=\"docs-palettes\"></div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #frente\" module_id=\"frente\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"frente\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"667\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Frente Parlamentar de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a0<strong>2022</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p><strong>Acima de 18 anos: 46,38% de obesidade e 29,79% de sobrepeso. </strong></p>\n<p><strong>Entre 13 e 17 anos: 21,58% de obesidade e 22,44% de sobrepeso. </strong></p>\n<p><strong>Entre 4 e 9 anos: 20,30% de obesidade e 17,09% de sobrepeso. </strong></p>\n<p><strong>Entre 2 e 4 anos: 10,04% de obesidade e 7,55% de sobrepeso.</strong></p>\n<p><strong> Abaixo de 2 anos: 3% de obesidade e 5,48% de sobrepeso. </strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||2px|||\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>Existe<strong> 1</strong> restaurante popular custeado pela prefeitura, com capacidade para preparar e distribuir um total de <strong>80 refei\u00e7\u00f5es diariamente</strong>, com alimentos fornecidos </span><span>pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #cozinha\" module_id=\"cozinha\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"cozinha\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"786\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Cozinha comunit\u00e1ria</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>Existem <strong>4</strong> cozinhas comunit\u00e1rias custeadas pela prefeitura, com capacidade para preparar e distribuir um total de <strong>1320 refei\u00e7\u00f5es diariamente</strong>, </span><span>com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio criou</span><span> </span><span>programa de transfer\u00eancia de renda no valor de <strong>R$ 660 e R$ 1320</strong> que atende um total aproximado de <strong>158 familias</strong> por m\u00eas. </span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>2</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>39</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o evento Fil\u00f3 de Vila Oliva e o evento S\u00e1lvia que ocorrem anualmente.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio tem um territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente<strong> 11\u00a0escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico/org\u00e2nico</strong>.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>3\u00a0hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>55000 mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #refrigerantes\" module_id=\"refrigerantes\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"refrigerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"874\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui lei/decreto que proibe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #ultraprocesssados\" module_id=\"ultraprocesssados\" module_class=\"popup\" _builder_version=\"4.25.0\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_margin=\"6px|||||\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"ultraprocesssados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"875\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui lei/decreto que proibe ou limita a venda da venda de ultraprocessados nas escolas</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa<strong> entre 30% a 50%</strong> do or\u00e7amento recebido pelo PNAE e <strong>metade</strong> da compra direta da AF vem da produ\u00e7\u00e3o local.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa <strong>10%</strong> em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>duas ou mais vezes por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Caxias do Sul","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/caxias-do-sul/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Caxias do Sul\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/04/Mapa-Caxias-do-Sul-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1712612999:7","%_last_editor_used_jetpack%":"block-editor","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-29.17477689916077","%_wpgmp_metabox_longitude%":"-51.18886207138418","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:29:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:1:\"9\";i:6;s:2:\"11\";i:7;s:2:\"12\";i:8;s:2:\"15\";i:9;s:2:\"16\";i:10;s:2:\"17\";i:11;s:2:\"18\";i:12;s:2:\"19\";i:13;s:2:\"20\";i:14;s:2:\"22\";i:15;s:2:\"23\";i:16;s:2:\"24\";i:17;s:2:\"26\";i:18;s:2:\"27\";i:19;s:2:\"28\";i:20;s:2:\"29\";i:21;s:2:\"33\";i:22;s:2:\"34\";i:23;s:2:\"35\";i:24;s:2:\"37\";i:25;s:2:\"38\";i:26;s:2:\"39\";i:27;s:2:\"45\";i:28;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_focuskw%":"Caxias do Sul","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de Caxias do Sul cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticas P\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_estimated-reading-time-minutes%":"13","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_page_template%":"default","%_et_pb_use_builder%":"on","%_et_pb_show_page_creation%":"off","%_et_pb_old_content%":"<!-- wp:divi/placeholder /-->","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"3216\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3391","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Caxias do Sul</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Caxias do Sul</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_populacao\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">463.501 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_quadro\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.652 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_pin\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=200%2C200&#038;ssl=1\" alt=\"Losan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=200%2C201&#038;ssl=1\" alt=\"Comsea\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=200%2C201&#038;ssl=1\" alt=\"Sisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=200%2C201&#038;ssl=1\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=200%2C201&#038;ssl=1\" alt=\"Caisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?resize=200%2C201&#038;ssl=1\" alt=\"Frente Parlamentar de SAN\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-456\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Frente Parlamentar de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=200%2C201&#038;ssl=1\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?resize=200%2C201&#038;ssl=1\" alt=\"Banco de alimentos municipal\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?resize=200%2C201&#038;ssl=1\" alt=\"Restaurante popular\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?resize=200%2C201&#038;ssl=1\" alt=\"Cozinha comunit\u00e1ria\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-490\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Cozinha comunit\u00e1ria</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras convencionais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=200%2C201&#038;ssl=1\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=200%2C201&#038;ssl=1\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png?resize=200%2C201&#038;ssl=1\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=200%2C200&#038;ssl=1\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?resize=200%2C201&#038;ssl=1\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_8 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_23 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas escolares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_24 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_25 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=200%2C201&#038;ssl=1\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_26 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png?resize=200%2C200&#038;ssl=1\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-460\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de refrigerante nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_27 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png?resize=200%2C200&#038;ssl=1\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-459\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_28 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=200%2C201&#038;ssl=1\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_9 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_29 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=200%2C201&#038;ssl=1\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_30 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png?resize=200%2C200&#038;ssl=1\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_31 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=200%2C201&#038;ssl=1\" alt=\"Controle de desmatamento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_32 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=200%2C201&#038;ssl=1\" alt=\"Coleta seletiva\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_33 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2012.<br />\nLEI N\u00ba 7241, de 26/03/2012.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2003, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02012.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02022.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: Secretaria Municipal de Agricultura Pecu\u00e1ria e Abastecimento, Funda\u00e7\u00e3o de Assist\u00eancia Social, Secretaria Municipal de Sa\u00fade, Secretaria Municipal de Educa\u00e7\u00e3o, Secretaria Municipal de Desenvolvimento Econ\u00f4mico e Inova\u00e7\u00e3o, Secretaria Municipal de Meio Ambiente e Secretaria Municipal de Seguran\u00e7a P\u00fablica e Prote\u00e7\u00e3o Social.<br />\nA presid\u00eancia \u00e9 exercida pela Secretaria Municipal de Agricultura Pecu\u00e1ria e Abastecimento.</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"frente\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Frente Parlamentar de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a02022.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: 46,38% de obesidade e 29,79% de sobrepeso.<br />\nEntre 13 e 17 anos: 21,58% de obesidade e 22,44% de sobrepeso.<br />\nEntre 4 e 9 anos: 20,30% de obesidade e 17,09% de sobrepeso.<br />\nEntre 2 e 4 anos: 10,04% de obesidade e 7,55% de sobrepeso.<br />\n Abaixo de 2 anos: 3% de obesidade e 5,48% de sobrepeso. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_42  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existe 1 restaurante popular custeado pela prefeitura, com capacidade para preparar e distribuir um total de 80 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"cozinha\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Cozinha comunit\u00e1ria</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 4 cozinhas comunit\u00e1rias custeadas pela prefeitura, com capacidade para preparar e distribuir um total de 1320 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 660 e R$ 1320 que atende um total aproximado de 158 familias por m\u00eas. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 2 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 39 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o evento Fil\u00f3 de Vila Oliva e o evento S\u00e1lvia que ocorrem anualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_51  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_52  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_53  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 11\u00a0escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 3\u00a0hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_55  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 55000 mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"refrigerantes\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_56  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que proibe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"ultraprocesssados\" class=\"et_pb_section et_pb_section_26 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_32\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_57  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que proibe ou limita a venda da venda de ultraprocessados nas escolas</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_27 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_58  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_28 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_34\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_59  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa entre 30% a 50% do or\u00e7amento recebido pelo PNAE e metade da compra direta da AF vem da produ\u00e7\u00e3o local.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_60  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 10% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_61  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_37\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_62  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada duas ou mais vezes por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2024-05-16 15:48:17","%_et_builder_version%":"VB|Divi|4.25.0","%_yoast_wpseo_content_score%":"30","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":3216,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Frente Parlamentar de SAN","id":"9","type":"category","extension_fields":{"cat_order":"6"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pactos internacionais","id":"11","type":"category","extension_fields":{"cat_order":"8"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Cozinha comunit\u00e1ria","id":"17","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de refrigerantes nas escolas","id":"34","type":"category","extension_fields":{"cat_order":"31"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de ultraprocessados nas escolas","id":"35","type":"category","extension_fields":{"cat_order":"32"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Careiro","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nCareiro <span class=\"fc-badge info\"></span></div>\r\n Amazonas, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/careiro/\">Ver mais</a></p></div>","content":"Amazonas, Brasil","location":{"lat":"-3.8208974387718326","lng":"-60.36460541926581","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/careiro/","zoom":5,"extra_fields":{"post_excerpt":"Amazonas, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>30.792 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>6.096 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.careiro.am.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/am/careiro.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" hover_enabled=\"0\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\" sticky_enabled=\"0\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" hover_enabled=\"0\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\" sticky_enabled=\"0\" link_option_url=\"#resiliencia\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN.<strong></strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p><strong>Acima de 18 anos: 20,77% de obesidade e 36,85% de sobrepeso. </strong></p>\n<p><strong>Entre 10 e 12 anos: 8,23% de obesidade e 17,2% de sobrepeso. </strong></p>\n<p><strong> Entre 2 e 4 anos: 4,26% de obesidade e 4,49% de sobrepeso. </strong></p>\n<p><strong>Abaixo de 2 anos: 5,55% de obesidade e 10,62% de sobrepeso.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio apresenta percentual de<strong> 21,59% de INSAN grave</strong>. O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de <strong>cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||2px|||\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existe <strong>1</strong> feira convencional funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados<strong> alimentos agroecol\u00f3gicos ou org\u00e2nicos. </strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como eventos para a educa\u00e7\u00e3o.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio tem um percentual de<strong> 70%</strong> do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui Programa de Hortas Escolares, cujo principal modelo de produ\u00e7\u00e3o \u00e9<strong> convencional</strong>. </span></p>\n<p><span>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a <strong>dire\u00e7\u00e3o da escola.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas<strong> 9.231\u00a0mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa entre <strong>30% a 50%</strong> do or\u00e7amento recebido pelo PNAE e <strong>metade da compra</strong> direta da AF vem da produ\u00e7\u00e3o local. </span></p>\n<p><span>As chamadas p\u00fablicas admitem propostas por detentores individuais de <strong>Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica)</strong>.</span></p>\n<p><span> No munic\u00edpio existe<strong> central de log\u00edstica</strong> para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos <strong>org\u00e2nicos ou agroecol\u00f3gicos</strong> e esta representa<strong> 2,19%</strong> em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui Plano de<strong> Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui iniciativa de<strong> restaura\u00e7\u00e3o de \u00e1reas degradas</strong> para uso agr\u00edcola (ainda que parcial).</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico </span><span>e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>duas ou mais vezes por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Careiro","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/careiro/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Careiro\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/04/careiro_tambaqui-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1712613379:7","%_last_editor_used_jetpack%":"block-editor","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-3.8208974387718326","%_wpgmp_metabox_longitude%":"-60.36460541926581","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:22:{i:0;s:1:\"4\";i:1;s:1:\"7\";i:2;s:2:\"11\";i:3;s:2:\"12\";i:4;s:2:\"14\";i:5;s:2:\"15\";i:6;s:2:\"19\";i:7;s:2:\"20\";i:8;s:2:\"22\";i:9;s:2:\"23\";i:10;s:2:\"24\";i:11;s:2:\"26\";i:12;s:2:\"28\";i:13;s:2:\"33\";i:14;s:2:\"37\";i:15;s:2:\"38\";i:16;s:2:\"39\";i:17;s:2:\"40\";i:18;s:2:\"44\";i:19;s:2:\"45\";i:20;s:2:\"46\";i:21;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_focuskw%":"Careiro","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de Careiro cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticas P\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_page_template%":"default","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"3214\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3399","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_32 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_39\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_63  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Careiro</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_33 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_64   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Careiro</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_populacao\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">30.792 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_quadro\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">6.096 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_pin\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_101 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_102 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_65    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_34 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_41 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_66  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_42 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_67  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_13_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_13 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_35 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_43 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_68 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=200%2C200&#038;ssl=1\" alt=\"Losan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_69 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=200%2C201&#038;ssl=1\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_70 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=200%2C201&#038;ssl=1\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_71 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png?resize=200%2C200&#038;ssl=1\" alt=\"Pesquisa de SAN\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_72 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?resize=200%2C201&#038;ssl=1\" alt=\"Banco de alimentos municipal\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_73 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_44 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_74 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras convencionais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_75 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=200%2C201&#038;ssl=1\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_76 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=200%2C201&#038;ssl=1\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_77 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png?resize=200%2C201&#038;ssl=1\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_78 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=200%2C200&#038;ssl=1\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_79 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas escolares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_45 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_80 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=200%2C201&#038;ssl=1\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_81 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=200%2C201&#038;ssl=1\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_82 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=200%2C201&#038;ssl=1\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_83 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_43 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png?resize=200%2C200&#038;ssl=1\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_84 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_44 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?resize=200%2C201&#038;ssl=1\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_85 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_45 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?resize=200%2C201&#038;ssl=1\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_46 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_86 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_46 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=200%2C201&#038;ssl=1\" alt=\"Controle de desmatamento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_87 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_47 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de compostagem\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_88 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_48 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=200%2C201&#038;ssl=1\" alt=\"Coleta seletiva\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_89 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_90 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_91 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_92  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_93  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_94  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: 20,77% de obesidade e 36,85% de sobrepeso.<br />\nEntre 10 e 12 anos: 8,23% de obesidade e 17,2% de sobrepeso.<br />\n Entre 2 e 4 anos: 4,26% de obesidade e 4,49% de sobrepeso.<br />\nAbaixo de 2 anos: 5,55% de obesidade e 10,62% de sobrepeso.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_50\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_95  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio apresenta percentual de 21,59% de INSAN grave. O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_96  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_41 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_52\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_97  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_42 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_98  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existe 1 feira convencional funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_43 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_54\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_99  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_126  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_44 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_100  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como eventos para a educa\u00e7\u00e3o.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_56\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_101  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um percentual de 70% do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_57\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_102  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_47 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_103  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_48 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_59\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_104  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 9.231\u00a0mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_49 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_60\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_105  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_144  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_145  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_50 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_61\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_106  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_146  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa entre 30% a 50% do or\u00e7amento recebido pelo PNAE e metade da compra direta da AF vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\n No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_51 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_62\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_107  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_149  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_150  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 2,19% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_151  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_52 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_63\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_108  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_152  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_153  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Plano de Resili\u00eancia &#8211; ou de A\u00e7\u00e3o &#8211; Clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_154  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_53 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_64\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_109  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_155  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_156  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_157  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_54 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_65\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_110  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_158  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_159  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_160  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_55 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_66\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_111  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_161  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_162  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_163  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_56 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_67\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_112  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_164  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_165  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada duas ou mais vezes por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_166  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2024-05-16 15:48:17","%_et_builder_version%":"VB|Divi|4.25.0","%_et_pb_show_page_creation%":"off","%_yoast_wpseo_content_score%":"60","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":3214,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pactos internacionais","id":"11","type":"category","extension_fields":{"cat_order":"8"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Campinas","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nCampinas <span class=\"fc-badge info\"></span></div>\r\n S\u00e3o Paulo, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/campinas/\">Ver mais</a></p></div>","content":"S\u00e3o Paulo, Brasil","location":{"lat":"-22.908575694842604","lng":"-47.08034669466898","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/campinas/","zoom":5,"extra_fields":{"post_excerpt":"S\u00e3o Paulo, Brasil","post_content":"<!-- wp:divi/placeholder -->\n[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>1.139.047 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>794 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://portal.campinas.sp.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/sp/campinas.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#ultraprocessados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"872\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pagamentos por Servi\u00e7os Ambientais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pagamentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"782\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2020</strong>.</p>\n<p><strong>LEI N\u00ba 15.912, de 18/06/2020</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2020.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2023</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os:<strong> secretaria da Sa\u00fade, Secretaria de Educa\u00e7\u00e3o, Secretaria de Assistencia Social, Secretaria Verde e Desenvolvimento Sustent\u00e1vel, Secretaria de\u00a0 Desenvolvimento Econ\u00f4mico, Social e de Turismo, Secretaria de Trabalho e Renda, Secretaria de Chefia de Gabinete do Prefeito, autarquias Ceasa, Sanasa, Setec. </strong></p>\n<p><span>A presid\u00eancia \u00e9 exercida pela <strong>secretaria de Assistencia Social, Pessoa com Deficiencia e Direitos Humanos.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 a de <strong>2021.</strong></p>\n<p>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</span></p>\n<p><strong> Acima de 18 anos: 46,76% de obesidade e 29,51% de sobrepeso</strong></p>\n<p><strong>Entre 10 a 17 anos: 18,81% de obesidade e 19,90% de sobrepeso </strong></p>\n<p><strong>Entre 4 e 9 anos: 16,96% de obesidade e 16,82% de sobrepeso </strong></p>\n<p><strong>Entre 2 e 4 anos: 3,50% de obesidade e 5,67% de sobrepeso </strong></p>\n<p><strong>Abaixo de 2 anos: 1,27% de obesidade e 5,12% de sobrepeso</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio apresenta percentual de 5,45% de INSAN grave e 2,21% de INSAN moderada</span>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||2px|||\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e\u00a0 compra da agricultura familiar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio criou</span><span> </span><span>programa de transfer\u00eancia de renda no valor de<strong> R$ 116,49</strong> e atende um total aproximado de <strong>2500</strong> beneficiados pela Renda Campinas e<strong> 6600</strong> do NutrirCampinas. </span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>12</strong>\u00a0feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem<strong> 121</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>\n<p>Tamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos patrocinados ou fomentados pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui lei de de incentivo \u00e0 agricultura urbana e periurbana.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>O\u00a0 principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico/org\u00e2nico</strong>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>2\u00a0hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>282\u00a0mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #ultraprocessados\" module_id=\"ultraprocessados\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"ultraprocessados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"875\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui lei/decreto que proibe ou limita a venda da venda de ultraprocessados nas escolas.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em\u00a0<strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>30% a 50%</strong> do or\u00e7amento recebido pelo PNAE e<strong> metade</strong> da compra direta vem da produ\u00e7\u00e3o local.</span></p>\n<p><span> As chamadas p\u00fablicas admitem propostas por detentores individuais de <strong>Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica)</strong>.</span></p>\n<p><span> No munic\u00edpio existe <strong>central de log\u00edstica</strong> para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa<strong> 40%</strong> em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pagamentos\" module_id=\"pagamentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pagamentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"795\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este <strong>inclui emiss\u00f5es relacionadas aos sistemas alimentares</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>uma vez</strong> <strong>por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]\n<!-- /wp:divi/placeholder -->","post_title":"Campinas","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/campinas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Campinas\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/04/Imagens-noticiasbiblioteca-LUPPA-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1712702512:7","%_last_editor_used_jetpack%":"block-editor","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-22.908575694842604","%_wpgmp_metabox_longitude%":"-47.08034669466898","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:30:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"11\";i:7;s:2:\"12\";i:8;s:2:\"14\";i:9;s:2:\"15\";i:10;s:2:\"18\";i:11;s:2:\"19\";i:12;s:2:\"20\";i:13;s:2:\"22\";i:14;s:2:\"23\";i:15;s:2:\"26\";i:16;s:2:\"27\";i:17;s:2:\"28\";i:18;s:2:\"29\";i:19;s:2:\"33\";i:20;s:2:\"35\";i:21;s:2:\"37\";i:22;s:2:\"38\";i:23;s:2:\"39\";i:24;s:2:\"40\";i:25;s:2:\"41\";i:26;s:2:\"42\";i:27;s:2:\"44\";i:28;s:2:\"45\";i:29;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_focuskw%":"Campinas","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de Campinas cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticas P\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_linkdex%":"36","%_yoast_wpseo_estimated-reading-time-minutes%":"14","%_yoast_wpseo_wordproof_timestamp%":"","%_wp_page_template%":"default","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"3212\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3405","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Campinas</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Campinas</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.139.047 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">794 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_8 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_23 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_24 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-459\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_25 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_26 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_27 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_28 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_9 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_29 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-485\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pagamentos por Servi\u00e7os Ambientais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_30 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_31 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_32 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_33 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2020.<br />\nLEI N\u00ba 15.912, de 18/06/2020.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02020.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: secretaria da Sa\u00fade, Secretaria de Educa\u00e7\u00e3o, Secretaria de Assistencia Social, Secretaria Verde e Desenvolvimento Sustent\u00e1vel, Secretaria de\u00a0 Desenvolvimento Econ\u00f4mico, Social e de Turismo, Secretaria de Trabalho e Renda, Secretaria de Chefia de Gabinete do Prefeito, autarquias Ceasa, Sanasa, Setec.<br />\nA presid\u00eancia \u00e9 exercida pela secretaria de Assistencia Social, Pessoa com Deficiencia e Direitos Humanos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 a de 2021.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\n Acima de 18 anos: 46,76% de obesidade e 29,51% de sobrepeso<br />\nEntre 10 a 17 anos: 18,81% de obesidade e 19,90% de sobrepeso<br />\nEntre 4 e 9 anos: 16,96% de obesidade e 16,82% de sobrepeso<br />\nEntre 2 e 4 anos: 3,50% de obesidade e 5,67% de sobrepeso<br />\nAbaixo de 2 anos: 1,27% de obesidade e 5,12% de sobrepeso</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_42  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio apresenta percentual de 5,45% de INSAN grave e 2,21% de INSAN moderada.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e\u00a0 compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 116,49 e atende um total aproximado de 2500 beneficiados pela Renda Campinas e 6600 do NutrirCampinas. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 12\u00a0feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 121 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos patrocinados ou fomentados pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei de de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_51  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nO\u00a0 principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_52  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 2\u00a0hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_53  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 282\u00a0mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"ultraprocessados\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que proibe ou limita a venda da venda de ultraprocessados nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_55  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em\u00a0desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_56  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de 30% a 50% do or\u00e7amento recebido pelo PNAE e metade da compra direta vem da produ\u00e7\u00e3o local.<br />\n As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\n No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_26 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_32\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_57  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 40% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_27 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_58  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pagamentos\" class=\"et_pb_section et_pb_section_28 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_34\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_59  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_60  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_61  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_37\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_62  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_32 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_38\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_63  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada uma vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 02:38:37","%_et_builder_version%":"VB|Divi|4.24.3","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_1f8e4317f4e208216e0c0091b52456d4":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_54c53e48f06980f6748698365f8ed397":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_01e35269ed9a966c5546fff0aa225981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_5a0bd7cb5eca803f6d357486e0709fca":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_2b7acd6904f10cee8d981acc1ea4d824":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_4176bab28cc9b2e7bacda9078a808209":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_a5d62d17e95e65b8f79663c1bc3c634e":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_bca74bf9a5c5bd48c49a3d6c32e26c5c":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_012a5040d0af8a3bcf40849ff8baaa12":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_8a19a379ad70facb592c17bbccebb64d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3c086b84a60744d163cbedac9c66cb4e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_91edb4bdd13c4bcca070fbe7a161e54c":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_40e35276edb08aa142e91da4398850c0":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_acce4e24add742dbbec7c4bdc245a6e4":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_eb3a089302b6c508286b3c8baf756796":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_2b5e35d4a97f3e0bee3bb0dffd29c50f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_977b90a6fb8e7f37ae43cd20cd918cc9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6649d73251ea6a18e5d206600298246b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_bb7b93f4babbe8edc5c951cf21bdcbeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_783800b43f0e4abf344e603dbbb3fcd6":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3d169557b8089f60f0bc76cf00869f7e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ed00174ee2629845133d1a97ea197b1b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_b0f45d679478b431e5fe9203b59e5e81":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_699e7e4a490cec8d44f209ef49562625":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8339c572ad7b20082abe93299f01b817":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_7352a25d42f823a4d80444302af4d227":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_898742e9d2a7c441130559e13cae950f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_76f000f035a17a8bdf1ae566926091ad":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1986162cb179633fb012dcb18b4c3d27":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_afb49c1da7a6ebbbfd5779488c0f39f3":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_145ab8b15bc361b85e161e2aa64a2d4b":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_466b366a0c7c1eefeadaba21a944f956":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b4323ea9a276e75160ae253dded76af2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9aa61753f322958804dabcdf4ab34d64":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1a3f67adef4aa6d9a16ccd98e9aa1d2a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4d1a336505729a06e3f973fafcea54ea":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f0fce30a74acf0475a1240d8b721cc0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_2dc868b7e9130d6e01f36e4d3ad88127":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_ee2cffcc9a467259555b63bcb2caf0e6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3c6950b96ab89da16b85d394437730d":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_220c4d5e8f37bc9b0c4035dedbbebb7a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_6aef04c39a068301c7c87908c550b097":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d7688747de5ede0b104897d7e5ff431a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f2673c7ff33c70c90d10e926397caefd":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d86b7944a72648aad2b02206e0c82c1a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a071358de769b683d941974803ce07d3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_33f7b40f7c3c3a952ce26076f37a9399":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_87d8efa144f14befeebea078da18e385":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_25c67584596ed420c429a8c7d7977279":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":3212,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pactos internacionais","id":"11","type":"category","extension_fields":{"cat_order":"8"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de ultraprocessados nas escolas","id":"35","type":"category","extension_fields":{"cat_order":"32"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa","id":"42","type":"category","extension_fields":{"cat_order":"39"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"M\u00e3e do Rio","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nM\u00e3e do Rio <span class=\"fc-badge info\"></span></div>\r\n Par\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/mae-do-rio/\">Ver mais</a></p></div>","content":"Par\u00e1, Brasil","location":{"lat":"-2.0101251765287875","lng":"-47.53476783894879","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/mae-do-rio/","zoom":5,"extra_fields":{"post_excerpt":"Par\u00e1, Brasil","post_content":"<!-- wp:divi/placeholder -->\n[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>34.353 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>470 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal\u00a0</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.24.2\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.24.2\" _module_preset=\"default\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/pa/mae-do-rio.html\" link_option_url_new_window=\"on\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.prefeituramaedorio.pa.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 Site da prefeitura</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/pa/mae-do-rio.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"six-columns\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.24.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_id=\"Itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2023</strong>.</p>\n<p><strong>LEI N\u00ba 734, de 2023.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2023</strong>, com composi\u00e7\u00e3o de <strong>maioria</strong> <strong>da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: <strong>Assist\u00eancia social, educa\u00e7\u00e3o, sa\u00fade, agricultura e meio ambiente.</strong><google-sheets-html-origin></google-sheets-html-origin></p>\n<p>A presid\u00eancia \u00e9 exercida pela <strong>Assist\u00eancia Social.\u00a0</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||2px|||\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e pela compra da agricultura familiar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio existem\u00a0feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itineirantes\" module_id=\"itineirantes\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" hover_enabled=\"0\" da_is_popup=\"on\" da_popup_slug=\"itineirantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" sticky_enabled=\"0\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio existem feiras itinerantes funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" custom_padding=\"||0px|||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos patrocinados ou fomentados pela prefeitura, como a feira do pescado.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" hover_enabled=\"0\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\" sticky_enabled=\"0\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui coselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>30% a\u00a0</strong> <strong>50% do or\u00e7amento</strong> recebido pelo PNAE e\u00a0 <strong>mais da metade </strong>vem da produ\u00e7\u00e3o local.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]\n<!-- /wp:divi/placeholder -->","post_title":"M\u00e3e do Rio","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/mae-do-rio/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"M\u00e3e do Rio\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/04/Mapa-Mae-do-Rio-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1712702749:7","%_last_editor_used_jetpack%":"block-editor","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-2.0101251765287875","%_wpgmp_metabox_longitude%":"-47.53476783894879","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:14:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"7\";i:3;s:1:\"8\";i:4;s:2:\"15\";i:5;s:2:\"19\";i:6;s:2:\"21\";i:7;s:2:\"22\";i:8;s:2:\"23\";i:9;s:2:\"26\";i:10;s:2:\"27\";i:11;s:2:\"30\";i:12;s:2:\"37\";i:13;s:2:\"38\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_focuskw%":"M\u00e3e do Rio","%_yoast_wpseo_linkdex%":"65","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"2986\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3409","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_33 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_64  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">M\u00e3e do Rio</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_34 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_65   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">M\u00e3e do Rio</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">34.353 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">470 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal\u00a0</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et_clickable et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_104 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 Site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_105 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_66    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_35 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_42 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_67  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_43 six-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_68  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_36 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_44 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_69 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_70 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_71 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_72 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_73 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_74 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_45 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_75 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div id=\"Itinerante\" class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_76 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_77 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_78 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_79 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_80 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_46 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_81 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_82 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_83 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_84 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_85 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_86 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_87  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2023.<br />\nLEI N\u00ba 734, de 2023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_88  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2023, com composi\u00e7\u00e3o de maioria da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_89  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_50\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_90  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: Assist\u00eancia social, educa\u00e7\u00e3o, sa\u00fade, agricultura e meio ambiente.<br />\nA presid\u00eancia \u00e9 exercida pela Assist\u00eancia Social.\u00a0</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_41 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_91  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e pela compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_42 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_52\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_92  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existem\u00a0feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itineirantes\" class=\"et_pb_section et_pb_section_43 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_93  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_126  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existem feiras itinerantes funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_44 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_54\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_94  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_95  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos patrocinados ou fomentados pela prefeitura, como a feira do pescado.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_56\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_96  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_47 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_57\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_97  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui coselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_48 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_98  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_49 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_59\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_99  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_144  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_145  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_50 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_60\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_100  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_146  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de 30% a\u00a0 50% do or\u00e7amento recebido pelo PNAE e\u00a0 mais da metade vem da produ\u00e7\u00e3o local.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 02:38:37","%_et_builder_version%":"VB|Divi|4.24.2","%_et_pb_show_page_creation%":"off","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de M\u00e3e do Rio cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticas P\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_content_score%":"60","%_wp_page_template%":"default","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":2986,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}}]},{"source":"post","title":"Caucaia","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nCaucaia <span class=\"fc-badge info\"></span></div>\r\n Cear\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/caucaia/\">Ver mais</a></p></div>","content":"Cear\u00e1, Brasil","location":{"lat":"-3.737950443709522","lng":"-38.65794871134756","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/caucaia/","zoom":5,"extra_fields":{"post_excerpt":"Cear\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>355.679 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.223 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://caucaia.ce.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/ce/caucaia.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"six-columns\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agicultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" hover_enabled=\"0\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\" sticky_enabled=\"0\"]<p>Agricultura Local</p>[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" hover_enabled=\"0\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\" sticky_enabled=\"0\" link_option_url=\"#resiliencia\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2006</strong>.</p>\n<p><strong>LEI N\u00ba 11.346, de 15/09/2006.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2023</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN.</p>\n<div id=\"docs-chrome\" role=\"banner\" aria-label=\"Barra de menus\" class=\"docs-material companion-enabled\" tabindex=\"0\">\n<div id=\"docs-additional-bars\">\n<div id=\"waffle-editorsized-bar\">\n<div id=\"waffle-db-delegation-banner-id\"></div>\n<div id=\"waffle-dbsource-configbar-id\"></div>\n<div id=\"waffle-filterbar-id\"></div>\n</div>\n</div>\n<div id=\"docs-transient-bar-container\"></div>\n<div id=\"docs-palettes\"></div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio formulou plano municipal de SAN. </span></p>\n<p><span>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||2px|||\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de<strong> doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio possui  feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio existem feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio tem mapeamento de produtores familiares. </span></p>\n<p><span>S\u00e3o produtores que produzem principalmente<strong> feij\u00e3o, milho, mandioca e peixes. </strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio </span><span>fornece <strong>mudas agroecol\u00f3gicas/org\u00e2nicas</strong></span><strong>.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui<strong> Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Caucaia","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/caucaia/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Caucaia\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/04/Mapa-Caucaia-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1714707874:417","%_last_editor_used_jetpack%":"block-editor","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-3.737950443709522","%_wpgmp_metabox_longitude%":"-38.65794871134756","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:14:{i:0;s:1:\"4\";i:1;s:1:\"6\";i:2;s:1:\"7\";i:3;s:1:\"8\";i:4;s:2:\"10\";i:5;s:2:\"15\";i:6;s:2:\"19\";i:7;s:2:\"20\";i:8;s:2:\"22\";i:9;s:2:\"25\";i:10;s:2:\"26\";i:11;s:2:\"31\";i:12;s:2:\"40\";i:13;s:2:\"45\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_wordproof_timestamp%":"","%_yoast_wpseo_focuskw%":"Caucaia","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de Caucaia cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticas P\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_linkdex%":"65","%_wp_page_template%":"default","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"3028\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3411","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Caucaia</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Caucaia</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">355.679 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.223 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 six-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-agicultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_8\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_23  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2006.<br />\nLEI N\u00ba 11.346, de 15/09/2006.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_24  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_25  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_26  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN.</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_28  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_29  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio possui  feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_30  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existem feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_31  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_32  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares.<br />\nS\u00e3o produtores que produzem principalmente feij\u00e3o, milho, mandioca e peixes. </div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_33  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Plano de Resili\u00eancia &#8211; ou de A\u00e7\u00e3o &#8211; Clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 02:33:00","%_et_builder_version%":"VB|Divi|4.25.0","%_et_pb_show_page_creation%":"off","%_yoast_wpseo_content_score%":"60","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_01e35269ed9a966c5546fff0aa225981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_1f8e4317f4e208216e0c0091b52456d4":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_988ebc0751e13e8199d9d89f073f8540":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_42b5dacf3cf7e1f57aabcbc2d873775e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_28fa3340f6760e3ba96933e580604e9e":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_a5d62d17e95e65b8f79663c1bc3c634e":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_4176bab28cc9b2e7bacda9078a808209":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_bca74bf9a5c5bd48c49a3d6c32e26c5c":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_91edb4bdd13c4bcca070fbe7a161e54c":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_acce4e24add742dbbec7c4bdc245a6e4":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_553102964bb4dbd4472c865cfb1544f7":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_e0e7cf488502f402dcfca32974becf3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_eb3a089302b6c508286b3c8baf756796":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_2b5e35d4a97f3e0bee3bb0dffd29c50f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_108ff824fd71c292d6571d452e37d745":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_40e35276edb08aa142e91da4398850c0":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_ed00174ee2629845133d1a97ea197b1b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_09c8f4ee8f1a3db1e111d479baa40699":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_898742e9d2a7c441130559e13cae950f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_67bc85a9c41108f62cceb82dd7a7c605":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_afb49c1da7a6ebbbfd5779488c0f39f3":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b4323ea9a276e75160ae253dded76af2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_0beaaade5e8eeaa3c0730602b6ac132d":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_f3a67b0f6b8f65a14c8fa6be6a2e2384":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_9aa61753f322958804dabcdf4ab34d64":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1a3f67adef4aa6d9a16ccd98e9aa1d2a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_83c0591d55f9aaceeb51537f61a50ba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b7fbe7594654b4e39f29781a316adc98":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_5a5159e6a5e9186d92e22d495a2c98cf":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d7688747de5ede0b104897d7e5ff431a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_502d4897d8cb4fd3b95aa138bab9cac0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":3028,"custom_filters":{"%regiao%":["Nordeste | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}}]},{"source":"post","title":"Jaguaretama","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nJaguaretama <span class=\"fc-badge info\"></span></div>\r\n Cear\u00e1, Brasil. \r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/jaguaretama/\">Ver mais</a></p></div>","content":"Cear\u00e1, Brasil. ","location":{"lat":"-5.608443822138814","lng":"-38.76282289625793","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/jaguaretama/","zoom":5,"extra_fields":{"post_excerpt":"Cear\u00e1, Brasil. ","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>17.232 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.826 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Semi\u00e1rido</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.jaguaretama.ce.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/ce/jaguaretama.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.24.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.3\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerantes\" hover_enabled=\"0\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\" sticky_enabled=\"0\"]<p>Abastecimento e Acesso a Alimentos</p>[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mapeamento\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2014</strong>.</p>\n<p><strong>LEI N\u00ba 886 de 2014 com emenda no Art. 9 atrav\u00e9s da lei 1209 de 2023.\u00a0</p>\n<p></strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2023</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em <b>2023.</b></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os:<span><strong> Secretaria de Assist\u00eancia Social, Cidadania e Empreendedorismo, Secretaria de Agricultura, Pecu\u00e1ria e Apoio Comunit\u00e1rio e a Secretaria de Sa\u00fade e secretaria de Educa\u00e7\u00e3o</strong>.</span></p>\n<p><span> A presid\u00eancia \u00e9 exercida pela Secretaria de <strong>Assist\u00eancia Social, Cidadania e Empreendedorismo.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 com o<strong> 1 plano em constru\u00e7\u00e3o.</strong> <br />Sua elabora\u00e7\u00e3o conta com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>obesidade (26,63%) e</strong>\u00a0<strong>sobrepeso (39,50%)</strong></p>\n<p>Entre 13 e 17 anos: <strong>obesidade (12,13%) e sobrepeso (23,30%)</strong></p>\n<p>Entre 10 e 12 anos: <strong>obesidade (12,13%) e sobrepeso (2,80%)</strong></p>\n<p>Entre 4 e 9 anos: <strong>obesidade (2,49%) e sobrepeso (11,39%)</strong></p>\n<p>Entre 2 e 4 anos: <strong>obesidade (19,50%) e sobrepeso (12,40%)</strong></p>\n<p>Abaixo de 2 anos: <strong>obesidade (12,71%) e sobrepeso (18,54%)</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de<strong> R$ 100,00</strong> e atende um total aproximado de <strong>200 beneficiados.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio existe 1 feira convencional funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerantes\" module_id=\"itinerantes\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio existem feiras itinerantes.\u00a0</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio existe mercado municipal.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>No municipio existem produtores que produzem principalmente <strong>feij\u00e3o, milho, queijo coalho, Galinha, bovinos, su\u00ednos, caprinos, ovinos, peixe, ovos, hortali\u00e7as, mel de abelha.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>1\u00a0escola</strong> possui horta, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <b>convencional</b>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a comunidade incluindo pais e alunos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" locked=\"off\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" custom_padding=\"||1px|||\" global_colors_info=\"{}\"]<p><span>O munic\u00edpio fornece <strong>mudas agroecol\u00f3gicas/org\u00e2nicas</strong> e possui programa ou parceria para cria\u00e7\u00e3o de <strong>banco de sementes crioulas.</strong></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>3281 mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa<strong> mais de 50%</strong> do or\u00e7amento recebido pelo PNAE e<strong> mais da metade</strong> da compra direta da AF vem da produ\u00e7\u00e3o local.</span><br /><span>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Jaguaretama","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/jaguaretama/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jaguaretama\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2024/04/Mapa-Jaguaretama-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1713793879:7","%_last_editor_used_jetpack%":"block-editor","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"7","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-5.608443822138814","%_wpgmp_metabox_longitude%":"-38.76282289625793","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:19:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"7\";i:3;s:1:\"8\";i:4;s:2:\"10\";i:5;s:2:\"12\";i:6;s:2:\"14\";i:7;s:2:\"18\";i:8;s:2:\"19\";i:9;s:2:\"21\";i:10;s:2:\"22\";i:11;s:2:\"25\";i:12;s:2:\"26\";i:13;s:2:\"28\";i:14;s:2:\"31\";i:15;s:2:\"33\";i:16;s:2:\"38\";i:17;s:2:\"44\";i:18;s:2:\"46\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_yoast_wpseo_estimated-reading-time-minutes%":"0","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"3070\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"3513","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_18 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Jaguaretama</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_19 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_38   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Jaguaretama</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">17.232 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.826 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Semi\u00e1rido</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_59 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_60 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_39    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_20 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_26 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_21 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_42 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_43 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_44 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_45 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_46 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_47 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_28 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_48 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_49 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_50 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_51 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_52 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_53 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_29 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_54 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_55 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_56 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_57 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_58 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_59 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_30 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_60 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_61 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_62 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_63 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_64 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_65  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_66  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2014.<br />\nLEI N\u00ba 886 de 2014 com emenda no Art. 9 atrav\u00e9s da lei 1209 de 2023.\u00a0</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_32\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_67  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2023, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_68  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em 2023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_34\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_69  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: Secretaria de Assist\u00eancia Social, Cidadania e Empreendedorismo, Secretaria de Agricultura, Pecu\u00e1ria e Apoio Comunit\u00e1rio e a Secretaria de Sa\u00fade e secretaria de Educa\u00e7\u00e3o.<br />\n A presid\u00eancia \u00e9 exercida pela Secretaria de Assist\u00eancia Social, Cidadania e Empreendedorismo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_26 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_70  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 com o 1 plano em constru\u00e7\u00e3o. Sua elabora\u00e7\u00e3o conta com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_27 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_71  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: obesidade (26,63%) e\u00a0sobrepeso (39,50%)<br />\nEntre 13 e 17 anos: obesidade (12,13%) e sobrepeso (23,30%)<br />\nEntre 10 e 12 anos: obesidade (12,13%) e sobrepeso (2,80%)<br />\nEntre 4 e 9 anos: obesidade (2,49%) e sobrepeso (11,39%)<br />\nEntre 2 e 4 anos: obesidade (19,50%) e sobrepeso (12,40%)<br />\nAbaixo de 2 anos: obesidade (12,71%) e sobrepeso (18,54%)</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_28 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_37\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_72  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_38\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_73  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 100,00 e atende um total aproximado de 200 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_39\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_74  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existe 1 feira convencional funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerantes\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_75  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existem feiras itinerantes.\u00a0</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_32 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_41\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_76  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existe mercado municipal.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_33 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_42\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_77  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No municipio existem produtores que produzem principalmente feij\u00e3o, milho, queijo coalho, Galinha, bovinos, su\u00ednos, caprinos, ovinos, peixe, ovos, hortali\u00e7as, mel de abelha.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_34 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_43\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_78  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_35 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_44\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_79  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 1\u00a0escola possui horta, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a comunidade incluindo pais e alunos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_45\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_80  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas e possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_46\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_81  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 3281 mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_82  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de 50% do or\u00e7amento recebido pelo PNAE e mais da metade da compra direta da AF vem da produ\u00e7\u00e3o local.As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_83  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_84  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 02:33:00","%_et_builder_version%":"VB|Divi|4.24.3","%_et_pb_show_page_creation%":"off","%_wp_page_template%":"default","%_yoast_wpseo_focuskw%":"Jaguaretama","%_yoast_wpseo_metadesc%":"Conhe\u00e7a o panorama do sistema alimentar presente no munic\u00edpio de Jaguaretama cidade participante do Laborat\u00f3rio Urbano de Pol\u00edticas P\u00fablicas Alimentares (LUPPA).","%_yoast_wpseo_linkdex%":"36","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Semi\u00e1rido","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":3070,"custom_filters":{"%regiao%":["Nordeste | Semi\u00e1rido"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}}]},{"source":"post","title":"Vit\u00f3ria do Xingu","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nVit\u00f3ria do Xingu <span class=\"fc-badge info\"></span></div>\r\n Par\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/vitoria-do-xingu/\">Ver mais</a></p></div>","content":"Par\u00e1, Brasil","location":{"lat":"-2.8855802","lng":"-52.0125317","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/vitoria-do-xingu/","zoom":5,"extra_fields":{"post_excerpt":"Par\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>15.421 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>3.089 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://vitoriadoxingu.pa.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pa/vitoria-do-xingu.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section]","post_title":"Vit\u00f3ria do Xingu","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/vitoria-do-xingu/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Vit\u00f3ria do Xingu\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_vitoria-xingu-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703277720:1","%_thumbnail_id%":"1174","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Vit\u00f3ria do Xingu","%_yoast_wpseo_linkdex%":"44","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1173\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"","%_et_pb_truncate_post_date%":"","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"11","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-2.8855802","%_wpgmp_metabox_longitude%":"-52.0125317","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":""}},"id":1173,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"]},"infowindow_disable":false},{"source":"post","title":"Natal","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nNatal <span class=\"fc-badge info\"></span></div>\r\n Rio Grande do Norte, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/natal/\">Ver mais</a></p></div>","content":"Rio Grande do Norte, Brasil","location":{"lat":"-5.7841695","lng":"-35.1999708","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/natal/","zoom":5,"extra_fields":{"post_excerpt":"Rio Grande do Norte, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>896.708 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>167 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://natal.rn.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/rn/natal.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section]","post_title":"Natal","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/natal/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Natal\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_natal-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275765:1","%_edit_last%":"1","%_thumbnail_id%":"748","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Natal","%_yoast_wpseo_linkdex%":"44","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1169\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"","%_et_pb_truncate_post_date%":"","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"11","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-5.7841695","%_wpgmp_metabox_longitude%":"-35.1999708","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Tropical","taxonomy=tema":""}},"id":1169,"custom_filters":{"%regiao%":["Nordeste | Tropical"]},"infowindow_disable":false},{"source":"post","title":"Florian\u00f3polis","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nFlorian\u00f3polis <span class=\"fc-badge info\"></span></div>\r\n Santa Catarina, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/florianopolis/\">Ver mais</a></p></div>","content":"Santa Catarina, Brasil","location":{"lat":"-27.5948036","lng":"-48.5569286","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/florianopolis/","zoom":5,"extra_fields":{"post_excerpt":"Santa Catarina, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>516.524 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>674 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/sc/florianopolis.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section]","post_title":"Florian\u00f3polis","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/florianopolis/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Florian\u00f3polis\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_florianopolis-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703274992:1","%_edit_last%":"1","%_thumbnail_id%":"743","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Florian\u00f3polis","%_yoast_wpseo_linkdex%":"44","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1164\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Florian\u00f3polis</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Florian\u00f3polis</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">516.524 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">674 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:52:09","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"11","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-27.5948036","%_wpgmp_metabox_longitude%":"-48.5569286","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Subtropical","taxonomy=tema":""}},"id":1164,"custom_filters":{"%regiao%":["Centro-Sul | Subtropical"]},"infowindow_disable":false},{"source":"post","title":"Rio Claro","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nRio Claro <span class=\"fc-badge info\"></span></div>\r\n S\u00e3o Paulo, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/rio-claro/\">Ver mais</a></p></div>","content":"S\u00e3o Paulo, Brasil","location":{"lat":"-22.4107652","lng":"-47.5596215","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/rio-claro/","zoom":5,"extra_fields":{"post_excerpt":"S\u00e3o Paulo, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>209.548 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>498 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://rioclaro.sp.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/sp/rio-claro.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section]","post_title":"Rio Claro","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/rio-claro/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rio Claro\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_rio-claro-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703277014:1","%_edit_last%":"1","%_thumbnail_id%":"755","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Rio Claro","%_yoast_wpseo_linkdex%":"44","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1160\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Rio Claro</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_4   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Rio Claro</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">209.548 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">498 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_16 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_17 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_5    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:52:09","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"11","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-22.4107652","%_wpgmp_metabox_longitude%":"-47.5596215","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":""}},"id":1160,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"]},"infowindow_disable":false},{"source":"post","title":"Jata\u00faba","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nJata\u00faba <span class=\"fc-badge info\"></span></div>\r\n Pernambuco, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/jatauba/\">Ver mais</a></p></div>","content":"Pernambuco, Brasil","location":{"lat":"-7.9857494","lng":"-36.49785110000001","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/jatauba/","zoom":5,"extra_fields":{"post_excerpt":"Pernambuco, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>17.305 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>714 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Semi\u00e1rido</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://jatauba.pe.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pe/jatauba.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section]","post_title":"Jata\u00faba","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/jatauba/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jata\u00faba\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_jatauba-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275048:1","%_thumbnail_id%":"744","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Jata\u00faba","%_yoast_wpseo_linkdex%":"44","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1156\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_4 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_6  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Jata\u00faba</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_5 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_7   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_16 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_2 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Jata\u00faba</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_11 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_8\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_18 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">17.305 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_12 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_20 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">714 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_13 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_21\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_10\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_22 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Semi\u00e1rido</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_14 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_23 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_25 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_26 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_8    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:52:09","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"11","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-7.9857494","%_wpgmp_metabox_longitude%":"-36.49785110000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_ab4b3fb39f4e898faa5bc7be3f2cae08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_f252d17b69546dbb6f96cb7dc35ef355":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_d36c591591e9202155ad5855343bd17c":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Semi\u00e1rido","taxonomy=tema":""}},"id":1156,"custom_filters":{"%regiao%":["Nordeste | Semi\u00e1rido"]},"infowindow_disable":false},{"source":"post","title":"Lajedo","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nLajedo <span class=\"fc-badge info\"></span></div>\r\n Pernambuco, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/lajedo/\">Ver mais</a></p></div>","content":"Pernambuco, Brasil","location":{"lat":"-8.6609153","lng":"-36.32352789999999","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/lajedo/","zoom":5,"extra_fields":{"post_excerpt":"Pernambuco, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>40.883 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>189 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Semi\u00e1rido</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.lajedo.pe.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pe/lajedo.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section]","post_title":"Lajedo","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/lajedo/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Lajedo\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_lajedo-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275453:1","%_edit_last%":"1","%_thumbnail_id%":"746","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Lajedo","%_yoast_wpseo_linkdex%":"44","%_yoast_wpseo_estimated-reading-time-minutes%":"1","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1152\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_6 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_7\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_9  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Lajedo</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_7 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_10   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_24 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_3 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Lajedo</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_16 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_25\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_12\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_26 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">40.883 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_17 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_27\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_28 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">189 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_18 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_29\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_14\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_30 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Semi\u00e1rido</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_19 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_31 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_34 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_35 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_11    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_15\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:52:09","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"11","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-8.6609153","%_wpgmp_metabox_longitude%":"-36.32352789999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"90","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Semi\u00e1rido","taxonomy=tema":""}},"id":1152,"custom_filters":{"%regiao%":["Nordeste | Semi\u00e1rido"]},"infowindow_disable":false},{"source":"post","title":"Alvar\u00e3es","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nAlvar\u00e3es <span class=\"fc-badge info\"></span></div>\r\n Amazonas, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/alvaraes/\">Ver mais</a></p></div>","content":"Amazonas, Brasil","location":{"lat":"-3.213751999999999","lng":"-64.80952239999999","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/alvaraes/","zoom":5,"extra_fields":{"post_excerpt":"Amazonas, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>16.396 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>5.923 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://transparenciamunicipalaam.org.br/p/alvaraes\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/am/alvaraes.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"four-columns\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>No munic\u00edpio, existe <strong>1</strong> feira convencional funcionando.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio tem um percentual de <strong>80%</strong> do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong></div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa <strong>menos de 30%</strong> do or\u00e7amento recebido pelo PNAE e <strong>metade</strong> vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Alvar\u00e3es","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/alvaraes/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alvar\u00e3es\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_alvaraes-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1707413724:1","%_thumbnail_id%":"732","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Alvar\u00e3es","%_yoast_wpseo_linkdex%":"56","%_yoast_wpseo_estimated-reading-time-minutes%":"4","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1147\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_8 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_12  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Alvar\u00e3es</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_9 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_13   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_32 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_4 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Alvar\u00e3es</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_21 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_33\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_16\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_34 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">16.396 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_22 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_35\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_36 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">5.923 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_23 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_37\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_18\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_38 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_24 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_39 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_43 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_44 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_14    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_10 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_15  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_12 four-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_16  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-uma-linha botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_11 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_23  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe 1 feira convencional funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_24  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_25  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um percentual de 80% do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_26  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE e metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:52:09","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-3.213751999999999","%_wpgmp_metabox_longitude%":"-64.80952239999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"1\";i:1;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"a:5:{i:0;s:2:\"19\";i:1;s:2:\"22\";i:2;s:2:\"24\";i:3;s:2:\"37\";i:4;s:2:\"38\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_last_editor_used_jetpack%":"block-editor","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_ab4b3fb39f4e898faa5bc7be3f2cae08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_652071d93f5f9b60e356cfa2e374cbeb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_cbed9aca9d38656dc80e3b5eeb8c3603":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_8fc5a9e5b93ca012284c44fc4c23f59e":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_0b681107d9bc310f2917e5cf0f133df8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_0cdf0a7f1ca4f48c7e174930475b21b5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_7536aec92985831f248cd6c805787202":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_84ef2cf18e7073d233795aa8986baef0":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4ca00974b15c50a47122180a04072878":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_cee412bcabe1b1d9f41c5e486abd4e85":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c3e82b15bbb267739265e8f82ac662e0":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_0732a27e72c02bfef6e258e7a838ca75":{"bosh":true,"pos":true,"anim":true},"et_pb_section_61b35ac49ef8f8f9934e52dc3002bff3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_710248152f3d66bebb8782a5d604106e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_b03104699b8eddf96b64429f99500e69":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_09085e781f4fe92f89192a57f40a4379":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_926915f01c59231473997dd9cfe8e7cf":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_38e10e3983110d62e1ee169004f86b5e":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_c85eda4e0dbb7f8733148378f942c3ab":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1147,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}}]},{"source":"post","title":"Alto Para\u00edso de Goi\u00e1s","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nAlto Para\u00edso de Goi\u00e1s <span class=\"fc-badge info\"></span></div>\r\n Goi\u00e1s, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/alto-paraiso-de-goias/\">Ver mais</a></p></div>","content":"Goi\u00e1s, Brasil","location":{"lat":"-14.133924765247405","lng":"-47.514744173221956","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/alto-paraiso-de-goias/","zoom":5,"extra_fields":{"post_excerpt":"Goi\u00e1s, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>10.298 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>4.019 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.altoparaiso.go.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/go/alto-paraiso-de-goias.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"five-columns\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>\n<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>Obesidade 25% e sobrepeso 34%</strong></p>\n<p>Entre 13 e 17 anos: <strong>Obesidade 25% e sobrepeso 34%</strong></p>\n<p>Entre 10 e 12 anos: <strong>Obesidade 25% e sobrepeso 34%</strong></p>\n<p>Entre 4 e 9 anos: <strong>Obesidade 25% e sobrepeso 24%</strong></p>\n<p>Entre 2 e 4 anos: <strong>Obesidade 15% e sobrepeso 24%</strong></p>\n<p>Abaixo de 2 anos: <strong>Obesidade 15% e sobrepeso 24%</strong></p>\n</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio possui <strong>4</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como um <strong>tour pelas propriedades da agricultura familiar</strong>.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio tem um percentual de <strong>30%</strong> do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p><span>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa<strong> mais de 50%</strong> do or\u00e7amento recebido pelo PNAE e mais da metade da compra direta da AF vem da produ\u00e7\u00e3o local. </span></p>\n<p><span>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa <strong>50%</strong> em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Alto Para\u00edso de Goi\u00e1s","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/alto-paraiso-de-goias/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Alto Para\u00edso de Goi\u00e1s\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_alto-paraiso-goias-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1707413707:1","%_thumbnail_id%":"731","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Alto Para\u00edso de Goi\u00e1s","%_yoast_wpseo_linkdex%":"62","%_yoast_wpseo_estimated-reading-time-minutes%":"10","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1140\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Alto Para\u00edso de Goi\u00e1s</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Alto Para\u00edso de Goi\u00e1s</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">10.298 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">4.019 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 five-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-uma-linha botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-uma-linha botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_7\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_17  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: Obesidade 25% e sobrepeso 34%<br />\nEntre 13 e 17 anos: Obesidade 25% e sobrepeso 34%<br />\nEntre 10 e 12 anos: Obesidade 25% e sobrepeso 34%<br />\nEntre 4 e 9 anos: Obesidade 25% e sobrepeso 24%<br />\nEntre 2 e 4 anos: Obesidade 15% e sobrepeso 24%<br />\nAbaixo de 2 anos: Obesidade 15% e sobrepeso 24%</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_8\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_18  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 4 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_19  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como um tour pelas propriedades da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_20  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um percentual de 30% do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_21  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_22  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_23  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de 50% do or\u00e7amento recebido pelo PNAE e mais da metade da compra direta da AF vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_24  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 50% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:51:22","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-14.133924765247405","%_wpgmp_metabox_longitude%":"-47.514744173221956","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:2:{i:0;s:1:\"1\";i:1;s:1:\"2\";}","%_wpgmp_metabox_marker_id%":"a:8:{i:0;s:2:\"12\";i:1;s:2:\"20\";i:2;s:2:\"23\";i:3;s:2:\"24\";i:4;s:2:\"26\";i:5;s:2:\"37\";i:6;s:2:\"38\";i:7;s:2:\"39\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%_last_editor_used_jetpack%":"block-editor","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_ab4b3fb39f4e898faa5bc7be3f2cae08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_73c9937bac52d82c87b86335bd307eb2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_6dba7b0ed28de7fd597a9a733d79beb0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_dee8b4a2421916ea5e52f618343ba7b5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_f9306b44795909a4455b275d445a3996":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_0b681107d9bc310f2917e5cf0f133df8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_0cdf0a7f1ca4f48c7e174930475b21b5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_7536aec92985831f248cd6c805787202":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_84ef2cf18e7073d233795aa8986baef0":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_65f2449efe4ad7d7a21dbf198e505ef8":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_012a5040d0af8a3bcf40849ff8baaa12":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4ca00974b15c50a47122180a04072878":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_cee412bcabe1b1d9f41c5e486abd4e85":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_2b5e35d4a97f3e0bee3bb0dffd29c50f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c3e82b15bbb267739265e8f82ac662e0":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_783800b43f0e4abf344e603dbbb3fcd6":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3d169557b8089f60f0bc76cf00869f7e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_27b27a2309dbb0bb5bfeae39a1f9b031":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_710248152f3d66bebb8782a5d604106e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_352bf6f2a921243f101b5c9a5af3f912":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_40f8286013448b58b0325ce6d5021b6e":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_09085e781f4fe92f89192a57f40a4379":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_926915f01c59231473997dd9cfe8e7cf":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_b4bf28b0e0af198c926a601dc3d1a5ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1a3f67adef4aa6d9a16ccd98e9aa1d2a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_38e10e3983110d62e1ee169004f86b5e":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c85eda4e0dbb7f8733148378f942c3ab":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_019c87ba3477d565f24c4f3ebab88426":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b0a3945802067be1d86358fb9eb468c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_220c4d5e8f37bc9b0c4035dedbbebb7a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1140,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}}]},{"source":"post","title":"Brejo da Madre de Deus","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nBrejo da Madre de Deus <span class=\"fc-badge info\"></span></div>\r\n Pernambuco, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/brejo-da-madre-de-deus/\">Ver mais</a></p></div>","content":"Pernambuco, Brasil","location":{"lat":"-8.1405443","lng":"-36.371496","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/brejo-da-madre-de-deus/","zoom":5,"extra_fields":{"post_excerpt":"Pernambuco, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>51.696 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>762 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Semi\u00e1rido</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://brejomdeus.pe.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pe/brejo-da-madre-de-deus.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mapeamento\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Central de beneficiamento de alimentos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#central\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"587\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2009</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2009</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2011</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2011</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>obesidade (37,48%) e sobrepeso (37,33%)</strong><br />Entre 13 e 17 anos: <strong>obesidade (9,38%) e sobrepeso (10,43%)</strong><br />Entre 4 e 9 anos: <strong>obesidade (10,86%) e sobrepeso (20,59%)</strong><br />Entre 2 e 4 anos: <strong>obesidade (10,81%) e sobrepeso (9,38%)</strong><br />Abaixo de 2 anos: <strong>obesidade (8,38%%) e sobrepeso (10,56%)</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>3</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem um percentual de <strong>20% do seu territ\u00f3rio</strong> de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p><span style=\"color: #000000; font-family: Roboto, Helvetica, Arial, Lucida, sans-serif; font-size: 15px; font-style: normal; font-variant-ligatures: normal; font-variant-caps: normal; font-weight: 300; letter-spacing: normal; orphans: 2; text-align: left; text-indent: 0px; text-transform: none; widows: 2; word-spacing: 0px; -webkit-text-stroke-width: 0px; white-space: normal; background-color: #ffffff; text-decoration-thickness: initial; text-decoration-style: initial; text-decoration-color: initial; display: inline !important; float: none;\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares.</p>\n<p>S\u00e3o <strong>3.250 produtores que possuem DAP</strong> (Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar), sendo 1.125 Ativas e 2.045 Expiradas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #central\" module_id=\"central\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"central\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"686\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Central de Beneficiamento de Alimentos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Central de Beneficiamento de Alimentos, como o <strong>Abatedouro Municipal, Casa do Mel e Casa de Polpa de Frutas</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>16 mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong> e em <strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa <strong>menos de 30% do or\u00e7amento</strong> recebido pelo PNAE e <strong>mais da metade vem da produ\u00e7\u00e3o local</strong>.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Brejo da Madre de Deus","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/brejo-da-madre-de-deus/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Brejo da Madre de Deus\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_brejo-madre-deus-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703274021:1","%_edit_last%":"1","%_thumbnail_id%":"739","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Brejo da Madre de Deus","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"8","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1134\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_12 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_25  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Brejo da Madre de Deus</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_13 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_26   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Brejo da Madre de Deus</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">51.696 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">762 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Semi\u00e1rido</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_41 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_42 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_27    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_14 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_28  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_19 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_29  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_15 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_30 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_31 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_32 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_33 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_34 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_35 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_21 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_36 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_37 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_38 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_39 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_40 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-454\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Central de beneficiamento de alimentos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_41 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_22 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_42 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_43 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_44 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2009.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2009, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02011.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_51  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02011.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_52  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: obesidade (37,48%) e sobrepeso (37,33%)Entre 13 e 17 anos: obesidade (9,38%) e sobrepeso (10,43%)Entre 4 e 9 anos: obesidade (10,86%) e sobrepeso (20,59%)Entre 2 e 4 anos: obesidade (10,81%) e sobrepeso (9,38%)Abaixo de 2 anos: obesidade (8,38%%) e sobrepeso (10,56%)</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_53  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 3 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_55  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um percentual de 20% do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_56  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_32\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_57  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares.<br />\nS\u00e3o 3.250 produtores que possuem DAP (Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar), sendo 1.125 Ativas e 2.045 Expiradas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"central\" class=\"et_pb_section et_pb_section_26 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_58  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Central de Beneficiamento de Alimentos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Central de Beneficiamento de Alimentos, como o Abatedouro Municipal, Casa do Mel e Casa de Polpa de Frutas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_27 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_34\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_59  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 16 mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_28 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_60  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_61  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE e mais da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_37\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_62  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:51:22","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-8.1405443","%_wpgmp_metabox_longitude%":"-36.371496","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:15:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:2:\"12\";i:5;s:2:\"14\";i:6;s:2:\"19\";i:7;s:2:\"24\";i:8;s:2:\"25\";i:9;s:2:\"26\";i:10;s:2:\"32\";i:11;s:2:\"33\";i:12;s:2:\"37\";i:13;s:2:\"38\";i:14;s:2:\"44\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Semi\u00e1rido","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1134,"custom_filters":{"%regiao%":["Nordeste | Semi\u00e1rido"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}}]},{"source":"post","title":"Anchieta","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nAnchieta <span class=\"fc-badge info\"></span></div>\r\n Santa Catarina, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/anchieta/\">Ver mais</a></p></div>","content":"Santa Catarina, Brasil","location":{"lat":"-26.5370815","lng":"-53.33115710000001","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/anchieta/","zoom":5,"extra_fields":{"post_excerpt":"Santa Catarina, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>5.477 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>232 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.anchieta.sc.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/sc/anchieta.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivo Fiscal\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#refrigerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"871\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#ultraprocessados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"872\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivos fiscais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"601\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Incentivo Fiscal</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2005</strong>, com composi\u00e7\u00e3o <strong>parit\u00e1ria</strong>.</p>\n<p>N\u00e3o possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>\n<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>obesidade (40%) e sobrepeso (30,62%)</strong><br />Entre 13 e 17 anos: <strong>obesidade (1,15%) e sobrepeso (1,91%)</strong><br />Entre 10 e 12 anos: <strong>obesidade (5,55%) e sobrepeso (5,55%)</strong><br />Entre 4 e 9 anos: <strong>obesidade (23%) e sobrepeso (1,91%)</strong><br />Entre 2 e 4 anos: <strong>obesidade (0,36%) e sobrepeso (0,57%)</strong></p>\n</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como a <strong>Feira de Sementes Crioulas</strong>, feira gastron\u00f4mica t\u00edpica de pratos saud\u00e1veis e com milho crioulo.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"][/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>827 refei\u00e7\u00f5es</strong> por dia.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #refrigerantes\" module_id=\"refrigerantes\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"refrigerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"874\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei/decreto que proibe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #ultraprocessados\" module_id=\"ultraprocessados\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"ultraprocessados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"875\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei/decreto que proibe ou limita a venda de ultraprocessados nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa <strong>30% a 50% do or\u00e7amento</strong> recebido pelo PNAE e <strong>50% vem da produ\u00e7\u00e3o local</strong>.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa <strong>40,38% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es</strong> para a alimenta\u00e7\u00e3o escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivos\" module_id=\"incentivos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivos fiscais</h5>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares, com isen\u00e7\u00e3o parcial no IPTU por dois anos para quem <strong>implantar cisternas, ceder terreno para horta, implantar sistema de energia solar e compostagem</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"707\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>INCENTIVO FISCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Anchieta","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/anchieta/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Anchieta\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_anchieta-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1707414262:1","%_thumbnail_id%":"733","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Anchieta","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1130\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_31 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_39\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_63  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Anchieta</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_32 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_64   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_16 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_2 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Anchieta</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_11 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_8\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_18 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">5.477 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_12 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_20 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">232 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_13 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_21\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_10\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_22 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_14 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_23 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_96 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_97 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_65    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_33 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_41 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_66  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_42 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_67  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_13_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_13 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_14_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_14 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_15_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_15 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_16_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_16 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_17_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_17 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_18_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_18 botao-uma-linha botao-filtros-cidades df-button dfc-incentivo et_pb_bg_layout_light\" href=\"\">Incentivo Fiscal</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_19_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_19 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_34 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_43 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_68 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_69 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_70 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_71 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_72 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_73 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_44 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_74 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-460\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de refrigerante nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_75 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-459\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_76 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_77 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_78 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_79 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_45 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_80 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-479\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivos fiscais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Incentivo Fiscal</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_81  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_82  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_83  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_84  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_85  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_35 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_46\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_86  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2005, com composi\u00e7\u00e3o parit\u00e1ria.<br />\nN\u00e3o possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_87  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: obesidade (40%) e sobrepeso (30,62%)Entre 13 e 17 anos: obesidade (1,15%) e sobrepeso (1,91%)Entre 10 e 12 anos: obesidade (5,55%) e sobrepeso (5,55%)Entre 4 e 9 anos: obesidade (23%) e sobrepeso (1,91%)Entre 2 e 4 anos: obesidade (0,36%) e sobrepeso (0,57%)</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_88  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como a Feira de Sementes Crioulas, feira gastron\u00f4mica t\u00edpica de pratos saud\u00e1veis e com milho crioulo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_89  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_50\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_90  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_91  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 827 refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"refrigerantes\" class=\"et_pb_section et_pb_section_41 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_52\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_92  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que proibe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"ultraprocessados\" class=\"et_pb_section et_pb_section_42 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_93  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que proibe ou limita a venda de ultraprocessados nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_43 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_54\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_94  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_44 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_95  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_126  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa 30% a 50% do or\u00e7amento recebido pelo PNAE e 50% vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_56\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_96  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 40,38% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_57\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_97  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivos\" class=\"et_pb_section et_pb_section_47 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_98  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Incentivos fiscais</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares, com isen\u00e7\u00e3o parcial no IPTU por dois anos para quem implantar cisternas, ceder terreno para horta, implantar sistema de energia solar e compostagem.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>INCENTIVO FISCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:51:22","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-26.5370815","%_wpgmp_metabox_longitude%":"-53.33115710000001","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:13:{i:0;s:1:\"5\";i:1;s:2:\"12\";i:2;s:2:\"23\";i:3;s:2:\"26\";i:4;s:2:\"29\";i:5;s:2:\"33\";i:6;s:2:\"34\";i:7;s:2:\"35\";i:8;s:2:\"37\";i:9;s:2:\"38\";i:10;s:2:\"39\";i:11;s:2:\"44\";i:12;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%_last_editor_used_jetpack%":"block-editor","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Subtropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Incentivo Fiscal, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1130,"custom_filters":{"%regiao%":["Centro-Sul | Subtropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Incentivo Fiscal","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de refrigerantes nas escolas","id":"34","type":"category","extension_fields":{"cat_order":"31"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de ultraprocessados nas escolas","id":"35","type":"category","extension_fields":{"cat_order":"32"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]},{"source":"post","title":"Maracana\u00fa","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nMaracana\u00fa <span class=\"fc-badge info\"></span></div>\r\n Cear\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/maracanau/\">Ver mais</a></p></div>","content":"Cear\u00e1, Brasil","location":{"lat":"-3.8682838","lng":"-38.6264568","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/maracanau/","zoom":5,"extra_fields":{"post_excerpt":"Cear\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>230.986 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>105 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.maracanau.ce.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/ce/maracanau.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"five-columns\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Cozinha comunit\u00e1ria\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#cozinha\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"775\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2012</strong></p>\n<p><strong>Lei Municipal n\u00ba 1.847 de 08 de Maio de 2012</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2013</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedades civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de <strong>Assit\u00eancia Social, Educa\u00e7\u00e3o, Sa\u00fade, Meio Ambiente e Desenvolvimento Econ\u00f4mico</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela secretaria de <strong>Assist\u00eancia Social.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de <strong>2018-2021</strong>.</p>\n<p>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de <strong>doa\u00e7\u00f5es de alimentos \u00e0 entidades cadastradas.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>01</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de <strong>750 refei\u00e7\u00f5es</strong> diariamente, com acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #cozinha\" module_id=\"cozinha\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"cozinha\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"786\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Cozinha comunit\u00e1ria</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>06</strong> cozinhas comunit\u00e1rias custeadas pela prefeitura, com capacidade para preparar e distribuir aproximadamente <strong>900 refei\u00e7\u00f5es</strong> diariamente, com acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>4</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>\n<p>Tamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>1 horta comunit\u00e1ria</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Maracana\u00fa","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/maracanau/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Maracana\u00fa\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_maracanau-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275573:1","%_thumbnail_id%":"747","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Maracana\u00fa","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1126\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_48 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_60\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_99  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Maracana\u00fa</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_49 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_100   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_24 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_3 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Maracana\u00fa</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_16 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_25\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_12\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_26 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">230.986 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_17 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_27\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_28 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">105 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_18 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_29\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_14\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_30 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_19 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_31 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_144  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_145 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_146 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_101    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_15\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_50 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_62 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_102  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_63 five-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_103  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_20_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_20 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_21_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_21 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_22_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_22 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_23_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_23 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_24_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_24 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_51 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_64 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_104 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_105 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_106 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_107 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_108 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_109 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_65 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_110 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_111 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_43 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-490\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Cozinha comunit\u00e1ria</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_112 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_44 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_113 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_45 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_114 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_46 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_115 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_47 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_52 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_66\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_116  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_149  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2012<br />\nLei Municipal n\u00ba 1.847 de 08 de Maio de 2012</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_150  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_53 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_67\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_117  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_151  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_152  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2013, com composi\u00e7\u00e3o de 2/3 da sociedades civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_153  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_54 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_68\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_118  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_154  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_155  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_156  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_55 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_69\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_119  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_157  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_158  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de Assit\u00eancia Social, Educa\u00e7\u00e3o, Sa\u00fade, Meio Ambiente e Desenvolvimento Econ\u00f4mico.<br />\nA presid\u00eancia \u00e9 exercida pela secretaria de Assist\u00eancia Social.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_159  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_56 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_70\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_120  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_160  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_161  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de 2018-2021.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_162  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_57 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_71\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_121  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_163  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_164  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00f5es de alimentos \u00e0 entidades cadastradas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_165  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_58 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_72\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_122  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_166  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_167  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 01 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de 750 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_168  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"cozinha\" class=\"et_pb_section et_pb_section_59 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_73\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_123  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_169  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Cozinha comunit\u00e1ria</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_170  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 06 cozinhas comunit\u00e1rias custeadas pela prefeitura, com capacidade para preparar e distribuir aproximadamente 900 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_171  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_60 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_74\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_124  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_172  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_173  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_174  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_61 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_75\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_125  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_175  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_176  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 4 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_177  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_62 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_76\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_126  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_178  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_179  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_180  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_63 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_77\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_127  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_181  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_182  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 1 horta comunit\u00e1ria e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_183  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:51:23","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-3.8682838","%_wpgmp_metabox_longitude%":"-38.6264568","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:12:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"7\";i:3;s:1:\"8\";i:4;s:2:\"10\";i:5;s:2:\"15\";i:6;s:2:\"16\";i:7;s:2:\"17\";i:8;s:2:\"19\";i:9;s:2:\"20\";i:10;s:2:\"22\";i:11;s:2:\"29\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_ab4b3fb39f4e898faa5bc7be3f2cae08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_597afbb7c5c3efebbea0c45827c4e5ab":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_6d5676d5b23bda9913a0516791b634d0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_dee8b4a2421916ea5e52f618343ba7b5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_203116a82b2790ceff68763dcbe471d8":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_65f2449efe4ad7d7a21dbf198e505ef8":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_6239435dff688575c4951096b663874c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_2fc07c01d0585c6ea59877d13afdae91":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4ca00974b15c50a47122180a04072878":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1ebe3b3be26177ce076c761c98c54925":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_bb75751ba0773f535532ff7ac206dcc9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_479d0c80d1f91ddc5971aa1c600455d7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_710248152f3d66bebb8782a5d604106e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1126,"custom_filters":{"%regiao%":["Nordeste | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Cozinha comunit\u00e1ria","id":"17","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}}]},{"source":"post","title":"Palmas","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nPalmas <span class=\"fc-badge info\"></span></div>\r\n Tocantins, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/palmas/\">Ver mais</a></p></div>","content":"Tocantins, Brasil","location":{"lat":"-10.227267329345393","lng":"-48.34724237752493","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/palmas/","zoom":5,"extra_fields":{"post_excerpt":"Tocantins, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>302.692 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>104.046 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.palmas.to.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/to/palmas.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"four-columns\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e Marcos Legais\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.3\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>\n<p>O munic\u00edpio possui LOSAN desde <strong>2012</strong>.</p>\n<p>Lei Municipal n\u00b0 1950/2012</p>\n</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2005</strong>, com composi\u00e7\u00e3o de maioria da sociedade civil.<br />Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em <strong>2024.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>\n<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de <strong>Assist\u00eancia Social, Educa\u00e7\u00e3o, Sa\u00fade, Desenvolvimento Rural e Desenvolvimento Econ\u00f4mico</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela secretaria de <strong>Assist\u00eancia Social</strong>.</p>\n</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>2</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de <strong>3.000</strong> refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>No munic\u00edpio, existem <strong>7</strong> feiras convencionais funcionando.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerante\" module_id=\"itinerante\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.25.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>No munic\u00edpio funcionam feiras itinerantes com comercialiaza\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o <strong>Festival Gastron\u00f4mico do Distrito de Taquaru\u00e7u.</strong></div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Palmas","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/palmas/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Palmas\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_palmas-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703276233:1","%_edit_last%":"1","%_thumbnail_id%":"751","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Palmas","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1119\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_64 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_79\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_128  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_184  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_185  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Palmas</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_65 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_129   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_32 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_4 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Palmas</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_186  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_21 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_33\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_16\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_34 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_187  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">302.692 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_22 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_35\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_36 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_188  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">104.046 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_23 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_37\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_18\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_38 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_189  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_24 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_39 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_190  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_191 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_192 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_130    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_66 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_81 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_131  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_193  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_82 four-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_132  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_25_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_25 botao-uma-linha botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e Marcos Legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_26_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_26 botao-uma-linha botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_27_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_27 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_28_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_28 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_67 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_83 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_133 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_48 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_134 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_49 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_135 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_50 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_136 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_51 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_137 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_52 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_138 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_53 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_84 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_139 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_54 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_140 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_55 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_141  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_142  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_143  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_144  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_68 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_85\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_145  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_194  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_195  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>O munic\u00edpio possui LOSAN desde 2012.<br />\nLei Municipal n\u00b0 1950/2012</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_196  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_69 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_86\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_146  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_197  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_198  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2005, com composi\u00e7\u00e3o de maioria da sociedade civil.Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_199  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_70 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_87\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_147  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_200  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_201  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em 2024.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_202  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_71 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_88\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_148  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_203  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_204  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de Assist\u00eancia Social, Educa\u00e7\u00e3o, Sa\u00fade, Desenvolvimento Rural e Desenvolvimento Econ\u00f4mico.<br />\nA presid\u00eancia \u00e9 exercida pela secretaria de Assist\u00eancia Social.</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_205  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_72 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_89\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_149  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_206  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_207  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 2 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de 3.000 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_208  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_73 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_90\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_150  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_209  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_210  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existem 7 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_211  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerante\" class=\"et_pb_section et_pb_section_74 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_91\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_151  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_212  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_213  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio funcionam feiras itinerantes com comercialiaza\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_214  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_75 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_92\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_152  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_215  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_216  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o Festival Gastron\u00f4mico do Distrito de Taquaru\u00e7u.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_217  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:51:23","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-10.227267329345393","%_wpgmp_metabox_longitude%":"-48.34724237752493","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:8:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"7\";i:3;s:1:\"8\";i:4;s:2:\"16\";i:5;s:2:\"19\";i:6;s:2:\"21\";i:7;s:2:\"23\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1119,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}}]},{"source":"post","title":"Bragan\u00e7a","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nBragan\u00e7a <span class=\"fc-badge info\"></span></div>\r\n Par\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/braganca/\">Ver mais</a></p></div>","content":"Par\u00e1, Brasil","location":{"lat":"-1.0570153","lng":"-46.7663161","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/braganca/","zoom":5,"extra_fields":{"post_excerpt":"Par\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>130.122 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>2.124 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://braganca.pa.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pa/braganca.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.3\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2011.</strong></p>\n<p><strong>Lei Municipal n\u00ba 4094, de 2011.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2009</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2014</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2015</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de <strong>Assist\u00eancia Social, Educa\u00e7\u00e3o, Sa\u00fade, Agricultura, Pesca e Cultura</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela secretaria de <strong>Assist\u00eancia Social</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 formulando seu <strong>1\u00ba plano municipal de SAN.</strong></p>\n<p>Sua elabora\u00e7\u00e3o conta com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>Obesidade 18,8% e sobrepeso 38,90%</strong><br />Entre 13 e 17 anos: <strong>Obesidade 6,8% e sobrepeso 18,80%</strong><br />Entre 4 e 9 anos: <strong>Sobrepeso 9%</strong><br />Entre 2 e 4 anos: <strong>Sobrepeso 5%</strong><br />Abaixo de 2 anos: <strong>Sobrepeso 8%</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<div>\n<div>O munic\u00edpio existem <strong>2 </strong>feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerante\" module_id=\"itinerante\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p><span>O munic\u00edpio realiza eventos gastron\u00f4micos anualmente, como a feira da gastronomia de frequencia anual, no qual mostra a culin\u00e1ria ancestral do caet\u00e9.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares feito no ano <strong>2017</strong>.</p>\n<p>S\u00e3o 2.083 produtores que produzem principalmente Cultivo da <strong>mandioca, feij\u00e3o, fruticultura e horticultura e pescados</strong>.</p>\n<p>Destes, 1.824 possuem DAP - Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>5 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>3 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de doa\u00e7\u00e3o de insumos e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>20 mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong> .</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa <strong>menos de 30%</strong> do or\u00e7amento recebido pelo PNAE e <strong>menos da metade</strong> vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>uma vez por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Bragan\u00e7a","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/braganca/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bragan\u00e7a\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_braganca-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703273883:1","%_edit_last%":"1","%_thumbnail_id%":"738","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Bragan\u00e7a","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"10","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1111\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Bragan\u00e7a</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Bragan\u00e7a</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">130.122 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">2.124 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_8 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_23 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_24 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_25 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_26 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_28  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_29  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2011.<br />\nLei Municipal n\u00ba 4094, de 2011.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_30  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2009, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_31  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02014.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_32  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02015.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_33  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de Assist\u00eancia Social, Educa\u00e7\u00e3o, Sa\u00fade, Agricultura, Pesca e Cultura.<br />\nA presid\u00eancia \u00e9 exercida pela secretaria de Assist\u00eancia Social.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 formulando seu 1\u00ba plano municipal de SAN.<br />\nSua elabora\u00e7\u00e3o conta com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: Obesidade 18,8% e sobrepeso 38,90%Entre 13 e 17 anos: Obesidade 6,8% e sobrepeso 18,80%Entre 4 e 9 anos: Sobrepeso 9%Entre 2 e 4 anos: Sobrepeso 5%Abaixo de 2 anos: Sobrepeso 8%</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 2 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerante\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos anualmente, como a feira da gastronomia de frequencia anual, no qual mostra a culin\u00e1ria ancestral do caet\u00e9.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares feito no ano 2017.<br />\nS\u00e3o 2.083 produtores que produzem principalmente Cultivo da mandioca, feij\u00e3o, fruticultura e horticultura e pescados.<br />\nDestes, 1.824 possuem DAP &#8211; Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_42  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 5 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 3 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 20 mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel .</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada uma vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:08:18","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-1.0570153","%_wpgmp_metabox_longitude%":"-46.7663161","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:22:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"12\";i:7;s:2:\"19\";i:8;s:2:\"21\";i:9;s:2:\"22\";i:10;s:2:\"23\";i:11;s:2:\"25\";i:12;s:2:\"26\";i:13;s:2:\"28\";i:14;s:2:\"29\";i:15;s:2:\"33\";i:16;s:2:\"37\";i:17;s:2:\"38\";i:18;s:2:\"41\";i:19;s:2:\"44\";i:20;s:2:\"45\";i:21;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1111,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Abaetetuba","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nAbaetetuba <span class=\"fc-badge info\"></span></div>\r\n Par\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/abaetetuba/\">Ver mais</a></p></div>","content":"Par\u00e1, Brasil","location":{"lat":"-1.7261394956015024","lng":"-48.88282360015405","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/abaetetuba/","zoom":5,"extra_fields":{"post_excerpt":"Par\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>97.378 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>160.439 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.abaetetuba.pa.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pa/abaetetuba.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.3\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.3\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2006.</strong></p>\n<p><strong>Lei Municipal n\u00ba213 de 08 de junho de 2006 e Lei de Altera\u00e7\u00e3o n\u00ba 371 de 04 de novembro de 2013.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2014</strong>, com composi\u00e7\u00e3o parit\u00e1ria.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>O munic\u00edpio aderiu ao SISAN <strong>em 2023</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2015</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de <strong>Agricultura, Sa\u00fade, Educa\u00e7\u00e3o, Assist\u00eancia Social e de Meio Ambiente</strong>. A presid\u00eancia \u00e9 exercida pela Secretaria Municipal de Assist\u00eancia Social.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>Obesidade 26,65 % e sobrepeso 41,22%</strong><br />Entre 10 e 12 anos: <strong>Obesidade 12,26%% e sobrepeso 24,92%</strong><br />Entre 2 e 4 anos: <strong>Obesidade 9,83% e sobrepeso 8%</strong><br />Abaixo de 2 anos: <strong>Obesidade 10,13% e sobrepeso 9,72%</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>3 </strong>feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>3 </strong>feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como a <strong>Miritifest</strong> uma vez ao ano</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares feito no ano 2020.</p>\n<p>S\u00e3o 90 produtores que produzem principalmente Horta e Mandioca.</p>\n<p>Destes, 70% possuem DAP - Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>1 escola</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>1 horta comunit\u00e1ria</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>31.941 refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong> e em <strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de <strong>30 a 50% do or\u00e7amento</strong> recebido pelo PNAE e <strong>mais da metade </strong>vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Abaetetuba","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/abaetetuba/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Abaetetuba\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_abaetuba-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1707414886:1","%_thumbnail_id%":"730","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Abaetetuba","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"10","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1101\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_25 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Abaetetuba</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_26 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_51   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Abaetetuba</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">97.378 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">160.439 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_80 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_81 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_52    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_27 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_53  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_34 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_13_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_13 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_28 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_55 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_56 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_57 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_58 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_59 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_60 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_36 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_61 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_62 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_63 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_64 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_65 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_66 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_37 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_67 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_68 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_69 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_70 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_71 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_72 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_38 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_73 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_74 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_75  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_76  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_77  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_78  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_39\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_79  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2006.<br />\nLei Municipal n\u00ba213 de 08 de junho de 2006 e Lei de Altera\u00e7\u00e3o n\u00ba 371 de 04 de novembro de 2013.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_80  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2014, com composi\u00e7\u00e3o parit\u00e1ria.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_41\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_81  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em 2023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_32 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_42\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_82  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02015.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_33 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_43\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_83  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de Agricultura, Sa\u00fade, Educa\u00e7\u00e3o, Assist\u00eancia Social e de Meio Ambiente. A presid\u00eancia \u00e9 exercida pela Secretaria Municipal de Assist\u00eancia Social.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_34 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_44\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_84  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: Obesidade 26,65 % e sobrepeso 41,22%Entre 10 e 12 anos: Obesidade 12,26%% e sobrepeso 24,92%Entre 2 e 4 anos: Obesidade 9,83% e sobrepeso 8%Abaixo de 2 anos: Obesidade 10,13% e sobrepeso 9,72%</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_35 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_45\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_85  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 3 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_46\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_86  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 3 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_87  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_88  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como a Miritifest uma vez ao ano</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_89  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares feito no ano 2020.<br />\nS\u00e3o 90 produtores que produzem principalmente Horta e Mandioca.<br />\nDestes, 70% possuem DAP &#8211; Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_50\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_90  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 1 escola possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_41 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_91  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 1 horta comunit\u00e1ria e o principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_42 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_52\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_92  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 31.941 refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_43 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_93  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_126  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_44 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_54\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_94  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de 30 a 50% do or\u00e7amento recebido pelo PNAE e mais da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_95  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_56\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_96  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:08:18","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-1.7261394956015024","%_wpgmp_metabox_longitude%":"-48.88282360015405","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:20:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"12\";i:6;s:2:\"19\";i:7;s:2:\"20\";i:8;s:2:\"21\";i:9;s:2:\"22\";i:10;s:2:\"23\";i:11;s:2:\"25\";i:12;s:2:\"28\";i:13;s:2:\"29\";i:14;s:2:\"33\";i:15;s:2:\"37\";i:16;s:2:\"38\";i:17;s:2:\"41\";i:18;s:2:\"45\";i:19;s:2:\"46\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_last_editor_used_jetpack%":"block-editor","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_1eb4849660fb97b46267ad5bf83ffcd3":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_5d79ac896b5927fc156ef09465962a3f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a36e8c413a9e79a73d713bda2290e474":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_012a5040d0af8a3bcf40849ff8baaa12":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_acce4e24add742dbbec7c4bdc245a6e4":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_7f43bbf565eb8cef0bb943d5703776d2":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_c59ea87f907bf24955ff85bb257e5f7c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ff38210f8b1af5a79614947885222155":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_783800b43f0e4abf344e603dbbb3fcd6":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_198913d5173b779bb427062f43ad8868":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_4a22aa923a59f8b9ff816c1289d81e85":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_019c87ba3477d565f24c4f3ebab88426":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_710248152f3d66bebb8782a5d604106e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b4323ea9a276e75160ae253dded76af2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_b3fd46f6ac4c20b7dc2857cede9bc1a9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_f3a67b0f6b8f65a14c8fa6be6a2e2384":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_de70cb9a1e9d68457ac578512ff6a551":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_e0e54bdbcebb3a8f09e13e444cb88d9f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1101,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}}]},{"source":"post","title":"Barcarena","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nBarcarena <span class=\"fc-badge info\"></span></div>\r\n Par\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/barcarena/\">Ver mais</a></p></div>","content":"Par\u00e1, Brasil","location":{"lat":"-1.508459035991229","lng":"-48.61635836176798","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/barcarena/","zoom":5,"extra_fields":{"post_excerpt":"Par\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>126.065 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>37.025 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://barcarena.pa.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pa/barcarena.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivos Fiscais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-incentivos\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.3\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerantes\" border_radii=\"on|5%|5%|5%|5%\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\" global_module=\"868\" theme_builder_area=\"post_content\"]<p>Abastecimento e Acesso a Alimentos</p>[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pagamentos por Servi\u00e7os Ambientais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pagamentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"782\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivos fiscais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"601\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Incentivo Fiscal</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-incentivos\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p><span>O munic\u00edpio possui LOSAN desde <strong>2023</strong>. </span></p>\n<p><span>Lei Municipal N\u00b0 2312, de 06 de Setembro de 2023.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p><span>O munic\u00edpio possui COMSEA instalado desde o ano de 2023, com composi\u00e7\u00e3o de 2/3 da Sociedade Civil. </span></p>\n<p><span>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo. A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>69,47%</strong></p>\n<p>Entre 13 e 17 anos: <strong>33,48%</strong></p>\n<p>Entre 5 e 9 anos: <strong>9,48%</strong></p>\n<p>Entre 2 e 4 anos: <strong>4,9%</strong></p>\n<p>Abaixo de 2 anos:<strong> 8,05%</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>No munic\u00edpio, existem feiras convencionais funcionando.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.24.2\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" theme_builder_area=\"post_content\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<div>\n<div>No munic\u00edpio existem\u00a0feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\" theme_builder_area=\"post_content\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos como o <strong>Festival do Abacaxi e de Ver\u00e3o</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares feito no ano <strong>2021</strong>, quando foi institu\u00eddo o Sistema Municipal de Monitoramento da Agricultura Familiar de Barcarena.</p>\n<p>S\u00e3o <strong>791 Agricultores Familiares; 1050 Ribeirinhos</strong> (Extrativistas e Pescadores Artesanais)</p>\n<p>Destes, <strong>895</strong> possuem DAP - Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"][/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pagamentos\" module_id=\"pagamentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pagamentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"795\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"][/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivos\" module_id=\"incentivos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui o <strong>IPTU VERDE</strong>, que \u00e9 um tipo de incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"707\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>INCENTIVO FISCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Barcarena","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/barcarena/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Barcarena\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_barcarena-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703273478:1","%_edit_last%":"1","%_thumbnail_id%":"735","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Barcarena","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1094\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_47 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_97  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Barcarena</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_48 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_98   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_16 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_2 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Barcarena</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_11 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_8\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_18 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">126.065 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_12 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_20 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">37.025 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_13 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_21\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_10\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_22 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_14 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_23 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_144 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_145 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_99    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_49 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_60 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_100  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_146  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_61 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_101  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_14_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_14 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_15_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_15 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_16_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_16 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_17_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_17 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_18_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_18 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_19_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_19 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_20_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_20 botao-filtros-cidades df-button dfc-incentivos et_pb_bg_layout_light\" href=\"\">Incentivos Fiscais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_21_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_21 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_50 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_62 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_102 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_103 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_104 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_105 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_106 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_43 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_107 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_44 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_63 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_108 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_45 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_109 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_46 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_110 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_47 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_111 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_48 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_112 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_49 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_113 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_50 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_64 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_114 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_51 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-485\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pagamentos por Servi\u00e7os Ambientais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_115 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_52 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_116 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_53 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_117 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_54 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-479\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivos fiscais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Incentivo Fiscal</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_118 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_119 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_65 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_120 dfc-incentivos  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_121  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_122  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_123  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_124  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_125  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_51 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_66\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_126  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2023.<br />\nLei Municipal N\u00b0 2312, de 06 de Setembro de 2023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_149  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_52 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_67\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_127  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_150  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_151  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2023, com composi\u00e7\u00e3o de 2/3 da Sociedade Civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo. A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_152  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_53 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_68\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_128  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_153  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_154  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: 69,47%<br />\nEntre 13 e 17 anos: 33,48%<br />\nEntre 5 e 9 anos: 9,48%<br />\nEntre 2 e 4 anos: 4,9%<br />\nAbaixo de 2 anos: 8,05%</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_155  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_54 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_69\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_129  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_156  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_157  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existem feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_158  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_55 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_70\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_130  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_159  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_160  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_161  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_56 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_71\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_131  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_162  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_163  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existem\u00a0feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_164  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_57 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_72\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_132  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_165  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_166  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos como o Festival do Abacaxi e de Ver\u00e3o.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_167  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_58 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_73\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_133  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_168  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_169  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares feito no ano 2021, quando foi institu\u00eddo o Sistema Municipal de Monitoramento da Agricultura Familiar de Barcarena.<br />\nS\u00e3o 791 Agricultores Familiares; 1050 Ribeirinhos (Extrativistas e Pescadores Artesanais)<br />\nDestes, 895 possuem DAP &#8211; Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_170  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_59 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_74\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_134  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_171  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_172  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_173  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_60 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_75\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_135  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_174  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_175  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_176  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_61 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_76\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_136  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_177  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_178  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_179  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_62 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_77\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_137  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_180  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_181  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_182  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pagamentos\" class=\"et_pb_section et_pb_section_63 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_78\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_138  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_183  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_184  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_185  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_64 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_79\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_139  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_186  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_187  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_188  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_65 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_80\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_140  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_189  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_190  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_191  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivos\" class=\"et_pb_section et_pb_section_66 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_81\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_141  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_192  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_193  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui o IPTU VERDE, que \u00e9 um tipo de incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_194  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>INCENTIVO FISCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:08:19","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-1.508459035991229","%_wpgmp_metabox_longitude%":"-48.61635836176798","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:19:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:2:\"12\";i:3;s:2:\"19\";i:4;s:2:\"20\";i:5;s:2:\"22\";i:6;s:2:\"23\";i:7;s:2:\"25\";i:8;s:2:\"26\";i:9;s:2:\"27\";i:10;s:2:\"28\";i:11;s:2:\"37\";i:12;s:2:\"38\";i:13;s:2:\"40\";i:14;s:2:\"41\";i:15;s:2:\"44\";i:16;s:2:\"45\";i:17;s:2:\"47\";i:18;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_f808ce26f8ab91197970dc22e2b1d8e2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_834fe7791cb73e58192ae859eeead8fb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_23517a7084550c305a833d75c090cdab":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f6caee21849f4ef7dfb10310b798b2dd":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a36e8c413a9e79a73d713bda2290e474":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_012a5040d0af8a3bcf40849ff8baaa12":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_dead83c7038c92cc0a95ff03e4b9135c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_acce4e24add742dbbec7c4bdc245a6e4":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_7f43bbf565eb8cef0bb943d5703776d2":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_2b5e35d4a97f3e0bee3bb0dffd29c50f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_977b90a6fb8e7f37ae43cd20cd918cc9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_8a1afe7790ddb0c9c3639a9fc0ccac9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_699e7e4a490cec8d44f209ef49562625":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_7352a25d42f823a4d80444302af4d227":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_c77d6d2f7e02ad7169f1688315680bea":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ab0b3d2a266ac92cd2ab4fbc0037fcc5":{"bosh":true,"pos":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_019c87ba3477d565f24c4f3ebab88426":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_4a22aa923a59f8b9ff816c1289d81e85":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b4323ea9a276e75160ae253dded76af2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_34a6c21b8c11e9ce6f0143618546fa19":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_46fe00281b0ac8f33a6be930546a180c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_4b2f3409eb70695e0d5babfb7b9a09df":{"bosh":true,"pos":true,"anim":true},"et_pb_text_b56a52bcd7cd67389decbc5fe2b995e0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_8f87ac4b97668c33753937622420a3b9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a31637abfea2df7550f9999b5c9c05ed":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f50cf8f4436757e67b743fa23268d1f1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_f3a67b0f6b8f65a14c8fa6be6a2e2384":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a81f5ba9e8c18b56e910512764f5e4c4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1a3f67adef4aa6d9a16ccd98e9aa1d2a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4d1a336505729a06e3f973fafcea54ea":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f0fce30a74acf0475a1240d8b721cc0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_6aef04c39a068301c7c87908c550b097":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d7688747de5ede0b104897d7e5ff431a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f2673c7ff33c70c90d10e926397caefd":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d86b7944a72648aad2b02206e0c82c1a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_87d8efa144f14befeebea078da18e385":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_25c67584596ed420c429a8c7d7977279":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ca98dc181feae921d6150627f60c5942":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c4226bc7119dad3a431f9e3e9a4068e7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_104c37f6c71c02fff00a1c281f8e3d22":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Incentivo Fiscal, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1094,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Incentivo Fiscal","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]},{"source":"post","title":"Caruaru","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nCaruaru <span class=\"fc-badge info\"></span></div>\r\n Pernambuco, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/caruaru/\">Ver mais</a></p></div>","content":"Pernambuco, Brasil","location":{"lat":"-8.1432856","lng":"-36.0458437","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/caruaru/","zoom":5,"extra_fields":{"post_excerpt":"Pernambuco, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>369.343 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>923 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Semi\u00e1rido</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://caruaru.pe.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pe/caruaru.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivo Fiscal\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Central de beneficiamento de alimentos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#central\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"587\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#ultraprocessados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"872\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivos fiscais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"601\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Incentivo Fiscal</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2010</strong> com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2014</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>\n<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>obesidade (35,92%) e sobrepeso (36,23%)</strong><br />Entre 13 e 17 anos: <strong>obesidade (11,13%) e sobrepeso (25,63%)</strong><br />Entre 10 e 12 anos: <strong>faixa n\u00e3o dispon\u00edvel</strong><br />Entre 4 e 9 anos: <strong>peso elevado para a idade 11,38%</strong><br />Entre 2 e 4 anos: <strong>peso elevado para a idade 7,36%</strong><br />Abaixo de 2 anos: <strong>peso elevado para a idade 7,4%</strong></p>\n</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>2</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>13</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>\n<p>Tamb\u00e9m existe uma central municipal de abastecimento de alimentos (CEACA), onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o <strong>Festival Comida de Feira</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio tem um percentual de <strong>0,0017%</strong> do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>19</strong> escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio fornece mudas agroecol\u00f3gicas/ org\u00e2nicas atrav\u00e9s da SAF.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #central\" module_id=\"central\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"central\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"686\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Central de Beneficiamento de Alimentos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Central de Beneficiamento de Alimentos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>124.144</strong> refei\u00e7\u00f5es por dia.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #ultraprocessados\" module_id=\"ultraprocessados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"ultraprocessados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"875\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei ou decreto que pro\u00edbe ou limita a venda da venda de ultraprocessados nas escolas</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa <strong>entre 30% e 50% do or\u00e7amento</strong> recebido pelo PNAE e <strong>mais da metade vem da produ\u00e7\u00e3o local</strong>.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 4<strong>1,95%</strong> em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>2 vez por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivos\" module_id=\"incentivos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivos fiscais</h5>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares, como o IPTU Verde e Refis.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"707\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>INCENTIVO FISCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Caruaru","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/caruaru/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Caruaru\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_caruaru-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703274248:1","%_thumbnail_id%":"740","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Caruaru","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"11","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1085\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_67 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_83\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_142  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_195  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_196  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Caruaru</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_68 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_143   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_24 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_3 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Caruaru</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_197  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_16 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_25\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_12\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_26 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_198  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">369.343 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_17 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_27\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_28 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_199  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">923 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_18 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_29\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_14\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_30 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_200  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Semi\u00e1rido</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_19 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_31 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_201  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_202 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_203 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_144    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_15\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_69 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_85 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_145  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_204  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_86 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_146  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_22_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_22 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_23_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_23 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_24_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_24 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_25_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_25 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_26_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_26 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_27_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_27 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_28_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_28 botao-uma-linha botao-filtros-cidades df-button dfc-incentivo et_pb_bg_layout_light\" href=\"\">Incentivo Fiscal</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_29_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_29 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_70 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_87 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_147 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_55 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_148 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_56 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_149 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_57 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_150 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_58 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_151 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_59 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_152 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_60 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_88 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_153 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_61 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_154 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_62 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_155 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_63 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_156 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_64 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_157 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_65 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_158 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_66 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_89 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_159 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_67 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_160 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_68 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-454\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Central de beneficiamento de alimentos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_161 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_69 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_162 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_70 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-459\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_163 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_71 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_164 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_72 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_90 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_165 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_73 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_166 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_74 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_167 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_75 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_168 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_76 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_169 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_77 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-479\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivos fiscais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Incentivo Fiscal</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_170  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_71 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_91\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_171  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_205  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_206  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2010 com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_207  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_72 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_92\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_172  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_208  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_209  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02014.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_210  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_73 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_93\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_173  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_211  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_212  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: obesidade (35,92%) e sobrepeso (36,23%)Entre 13 e 17 anos: obesidade (11,13%) e sobrepeso (25,63%)Entre 10 e 12 anos: faixa n\u00e3o dispon\u00edvelEntre 4 e 9 anos: peso elevado para a idade 11,38%Entre 2 e 4 anos: peso elevado para a idade 7,36%Abaixo de 2 anos: peso elevado para a idade 7,4%</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_213  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_74 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_94\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_174  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_214  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_215  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_216  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_75 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_95\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_175  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_217  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_218  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 2 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_219  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_76 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_96\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_176  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_220  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_221  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 13 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_222  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_77 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_97\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_177  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_223  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_224  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m existe uma central municipal de abastecimento de alimentos (CEACA), onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_225  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_78 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_98\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_178  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_226  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_227  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o Festival Comida de Feira.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_228  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_79 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_99\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_179  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_229  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_230  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um percentual de 0,0017% do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_231  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_80 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_100\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_180  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_232  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_233  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_234  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_81 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_101\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_181  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_235  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_236  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 19 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_237  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_82 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_102\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_182  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_238  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_239  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_240  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_83 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_103\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_183  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_241  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_242  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/ org\u00e2nicas atrav\u00e9s da SAF.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_243  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"central\" class=\"et_pb_section et_pb_section_84 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_104\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_184  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_244  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Central de Beneficiamento de Alimentos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_245  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Central de Beneficiamento de Alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_246  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_85 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_105\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_185  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_247  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_248  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 124.144 refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_249  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"ultraprocessados\" class=\"et_pb_section et_pb_section_86 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_106\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_186  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_250  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_251  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei ou decreto que pro\u00edbe ou limita a venda da venda de ultraprocessados nas escolas</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_252  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_87 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_107\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_187  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_253  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_254  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_255  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_88 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_108\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_188  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_256  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_257  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa entre 30% e 50% do or\u00e7amento recebido pelo PNAE e mais da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_258  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_89 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_109\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_189  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_259  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_260  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 41,95% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_261  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_90 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_110\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_190  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_262  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_263  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_264  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_91 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_111\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_191  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_265  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_266  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_267  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_92 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_112\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_192  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_268  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_269  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada 2 vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_270  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivos\" class=\"et_pb_section et_pb_section_93 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_113\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_193  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_271  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Incentivos fiscais</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_272  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares, como o IPTU Verde e Refis.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_273  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>INCENTIVO FISCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:08:19","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-8.1432856","%_wpgmp_metabox_longitude%":"-36.0458437","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:23:{i:0;s:1:\"5\";i:1;s:1:\"7\";i:2;s:2:\"12\";i:3;s:2:\"14\";i:4;s:2:\"19\";i:5;s:2:\"20\";i:6;s:2:\"22\";i:7;s:2:\"23\";i:8;s:2:\"24\";i:9;s:2:\"26\";i:10;s:2:\"28\";i:11;s:2:\"30\";i:12;s:2:\"31\";i:13;s:2:\"32\";i:14;s:2:\"33\";i:15;s:2:\"35\";i:16;s:2:\"37\";i:17;s:2:\"38\";i:18;s:2:\"39\";i:19;s:2:\"45\";i:20;s:2:\"46\";i:21;s:2:\"47\";i:22;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Semi\u00e1rido","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Incentivo Fiscal, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1085,"custom_filters":{"%regiao%":["Nordeste | Semi\u00e1rido"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Incentivo Fiscal","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de ultraprocessados nas escolas","id":"35","type":"category","extension_fields":{"cat_order":"32"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]},{"source":"post","title":"Teresina","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nTeresina <span class=\"fc-badge info\"></span></div>\r\n Piau\u00ed, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/teresina/\">Ver mais</a></p></div>","content":"Piau\u00ed, Brasil","location":{"lat":"-5.086209033386274","lng":"-42.77404080753912","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/teresina/","zoom":5,"extra_fields":{"post_excerpt":"Piau\u00ed, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>871.126 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.391 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://pmt.pi.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pi/teresina.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#refrigerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"871\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#ultraprocessados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"872\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2014.</strong></p>\n<p><strong>LOSAN n\u00ba 4.593 DE 24 DE JUNHO DE 2014</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2014</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em <strong>2016</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em <strong>2015</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias <strong>SEMCASPI, SEMPLAN, SEMEC, SDR, FMS, SEMAM, SEMGOV E SEMEL</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela secretaria <strong>SEMCASPI</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Existe <strong>1</strong> restaurante popular custeado pela prefeitura, com capacidade para preparar e distribuir um total de <strong>1.100</strong> refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>2</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerante\" module_id=\"itinerante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal.</p>\n<p>Tamb\u00e9m existe central estadual de abastecimento de alimentos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>42 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #refrigerantes\" module_id=\"refrigerantes\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"refrigerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"874\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei/decreto que pro\u00edbe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #ultraprocessados\" module_id=\"ultraprocessados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"ultraprocessados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"875\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei/decreto que pro\u00edbe ou limita a venda da venda de ultraprocessados nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong> e em <strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>30 a 50% do or\u00e7amento</strong> recebido pelo PNAE.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Teresina","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/teresina/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Teresina\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_teresina-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703277536:1","%_thumbnail_id%":"729","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Teresina","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1072\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_94 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_115\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_194  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_274  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_275  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Teresina</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_95 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_195   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_32 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_4 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Teresina</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_276  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_21 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_33\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_16\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_34 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_277  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">871.126 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_22 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_35\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_36 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_278  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.391 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_23 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_37\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_18\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_38 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_279  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_24 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_39 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_280  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_281 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_282 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_196    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_96 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_117 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_197  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_283  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_118 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_198  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_30_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_30 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_31_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_31 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_32_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_32 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_33_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_33 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_34_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_34 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_35_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_35 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_36_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_36 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_97 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_119 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_199 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_78 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_200 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_79 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_201 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_80 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_202 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_81 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_203 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_82 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_204 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_83 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_120 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_205 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_84 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_206 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_85 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_207 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_86 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_208 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_87 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_209 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_88 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_210 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_89 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-460\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de refrigerante nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_121 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_211 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_90 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-459\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_212 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_91 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_213 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_92 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_214 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_93 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_215 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_94 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_216 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_95 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_122 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_217 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_96 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_218  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_219  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_220  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_221  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_222  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_98 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_123\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_223  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_284  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_285  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2014.<br />\nLOSAN n\u00ba 4.593 DE 24 DE JUNHO DE 2014</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_286  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_99 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_124\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_224  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_287  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_288  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2014, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_289  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_100 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_125\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_225  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_290  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_291  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em 2016.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_292  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_101 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_126\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_226  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_293  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_294  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em 2015.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_295  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_102 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_127\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_227  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_296  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_297  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias SEMCASPI, SEMPLAN, SEMEC, SDR, FMS, SEMAM, SEMGOV E SEMEL.<br />\nA presid\u00eancia \u00e9 exercida pela secretaria SEMCASPI.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_298  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_103 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_128\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_228  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_299  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_300  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existe 1 restaurante popular custeado pela prefeitura, com capacidade para preparar e distribuir um total de 1.100 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_301  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_104 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_129\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_229  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_302  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_303  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 2 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_304  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerante\" class=\"et_pb_section et_pb_section_105 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_130\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_230  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_305  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_306  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_307  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_106 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_131\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_231  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_308  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_309  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_310  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_107 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_132\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_232  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_311  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_312  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_313  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_108 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_133\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_233  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_314  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_315  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 42 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_316  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"refrigerantes\" class=\"et_pb_section et_pb_section_109 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_134\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_234  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_317  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_318  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que pro\u00edbe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_319  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"ultraprocessados\" class=\"et_pb_section et_pb_section_110 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_135\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_235  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_320  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_321  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que pro\u00edbe ou limita a venda da venda de ultraprocessados nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_322  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_111 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_136\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_236  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_323  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_324  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_325  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_112 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_137\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_237  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_326  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_327  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de 30 a 50% do or\u00e7amento recebido pelo PNAE.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_328  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_113 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_138\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_238  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_329  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_330  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_331  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_114 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_139\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_239  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_332  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_333  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_334  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_115 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_140\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_240  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_335  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_336  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_337  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_116 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_141\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_241  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_338  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_339  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_340  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:08:20","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-5.086209033386274","%_wpgmp_metabox_longitude%":"-42.77404080753912","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:19:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"16\";i:6;s:2:\"19\";i:7;s:2:\"20\";i:8;s:2:\"22\";i:9;s:2:\"26\";i:10;s:2:\"29\";i:11;s:2:\"34\";i:12;s:2:\"35\";i:13;s:2:\"37\";i:14;s:2:\"38\";i:15;s:2:\"39\";i:16;s:2:\"45\";i:17;s:2:\"46\";i:18;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_f7deef4fb5e1931a312c8a834a9d0620":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_da2954c25381b04c7f60edb53fc048a0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8156e683614bff95cdef244f7b9d0c05":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_15d5a93135ffaaa2acbdca9ac945e548":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_2b5e35d4a97f3e0bee3bb0dffd29c50f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_7fbbf35cc66a7551dba30bc18fe7e75b":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_bb7b93f4babbe8edc5c951cf21bdcbeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3d169557b8089f60f0bc76cf00869f7e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_198913d5173b779bb427062f43ad8868":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_25c515a8c7c838cc5bf115b564771e49":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_fbe921604b5bfc09e35aa98db93b9f80":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a81f5ba9e8c18b56e910512764f5e4c4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1a3f67adef4aa6d9a16ccd98e9aa1d2a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_e5b69360a4f76fa7c21682275585ad96":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ac0cf0f282102f2545db00069dcf5aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f21f98a7e69347ea6a73c341610097e4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_ee2cffcc9a467259555b63bcb2caf0e6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4a05a17bb0504c5cd1cacca1d674db05":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_220c4d5e8f37bc9b0c4035dedbbebb7a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_de70cb9a1e9d68457ac578512ff6a551":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_e0e54bdbcebb3a8f09e13e444cb88d9f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1072,"custom_filters":{"%regiao%":["Nordeste | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de refrigerantes nas escolas","id":"34","type":"category","extension_fields":{"cat_order":"31"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de ultraprocessados nas escolas","id":"35","type":"category","extension_fields":{"cat_order":"32"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Sobral","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nSobral <span class=\"fc-badge info\"></span></div>\r\n Cear\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/sobral/\">Ver mais</a></p></div>","content":"Cear\u00e1, Brasil","location":{"lat":"-3.6844057","lng":"-40.35617939999999","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/sobral/","zoom":5,"extra_fields":{"post_excerpt":"Cear\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>212.437 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>2.068 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Semi\u00e1rido</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.sobral.ce.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/ce/sobral.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Cozinha comunit\u00e1ria\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#cozinha\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"775\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mapeamento\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Central de beneficiamento de alimentos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#central\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"587\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2015.</strong></p>\n<p><strong>Lei Municipal n\u00ba 1535 de 23 Dezembro de 2015</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2003</strong>, com composi\u00e7\u00e3o de <strong>maioria da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias dos <strong>Direitos Humanos e da Asist\u00eancia Social-SEDHAS, SEDHAS, Secretaria Municipal de Educa\u00e7\u00e3o-SME, Secretaria do Trabalho e Desenvolvimento Econ\u00f4mico-STDE e Secretaria Municipal de Sa\u00fade- SMS</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela Secretaria dos <strong>Direitos Humanos e da Assist\u00eancia Social-SEDHAS</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>obesidade (40,09%) e sobrepeso (35,36%);</strong><br />Entre 13 e 17 anos: <strong>obesidade (17,76%) e sobrepeso (23,23%);</strong><br />Entre 10 e 12 anos: <strong>obesidade e sobrepeso (n\u00e3o informado);</strong><br />Entre 5 e 9 anos: <strong>obesidade (24,16%) e sobrepeso (19,39%);</strong><br />Entre 2 e 4 anos: <strong>obesidade (10,44%) e sobrepeso (18,87%);</strong><br />Abaixo de 2 anos: <strong>obesidade (11,88%) e sobrepeso (5,98%)</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #cozinha\" module_id=\"cozinha\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"cozinha\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"786\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Cozinha comunit\u00e1ria</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>02</strong> cozinhas comunit\u00e1rias custeadas pela prefeitura, com capacidade para preparar e distribuir aproximadamente <strong>55 refei\u00e7\u00f5es</strong> diariamente.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 105,00</strong> em m\u00e9dia e atende um total aproximado de <strong>100</strong> beneficiados.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>2</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares em andamento.</p>\n<p>S\u00e3o produtores que produzem principalmente:</p>\n<ul>\n<li>Agropecu\u00e1ria: milho, feij\u00e3o, melancia, jerimum, hortali\u00e7as e algumas \u00e1reas frut\u00edferas.</li>\n<li>Apicultura</li>\n<li>Pecu\u00e1ria. Bovino, caprino, ovinos, su\u00ednos e aves.</li>\n<li>Extrativismo cera e a palha de carna\u00faba.</li>\n</ul>\n<p>Destes, 2021 possuem ativamente DAP - Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>16 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #central\" module_id=\"central\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"central\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"686\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Central de Beneficiamento de Alimentos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Central de Beneficiamento de Alimentos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>62.666 refei\u00e7\u00f5es por dia</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong> e em <strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>30 a 50% do or\u00e7amento</strong> recebido pelo PNAE e <strong>mais da metade </strong>vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>duas vezes por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Sobral","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/sobral/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Sobral\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_sobral-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703277402:1","%_thumbnail_id%":"728","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Sobral","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"11","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1063\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Sobral</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Sobral</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">212.437 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">2.068 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Semi\u00e1rido</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-490\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Cozinha comunit\u00e1ria</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-454\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Central de beneficiamento de alimentos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_8 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_23 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_24 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_25 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_26 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_28  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_29  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2015.<br />\nLei Municipal n\u00ba 1535 de 23 Dezembro de 2015.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_30  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2003, com composi\u00e7\u00e3o de maioria da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_31  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_32  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias dos Direitos Humanos e da Asist\u00eancia Social-SEDHAS, SEDHAS, Secretaria Municipal de Educa\u00e7\u00e3o-SME, Secretaria do Trabalho e Desenvolvimento Econ\u00f4mico-STDE e Secretaria Municipal de Sa\u00fade- SMS.<br />\nA presid\u00eancia \u00e9 exercida pela Secretaria dos Direitos Humanos e da Assist\u00eancia Social-SEDHAS</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_33  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: obesidade (40,09%) e sobrepeso (35,36%);Entre 13 e 17 anos: obesidade (17,76%) e sobrepeso (23,23%);Entre 10 e 12 anos: obesidade e sobrepeso (n\u00e3o informado);Entre 5 e 9 anos: obesidade (24,16%) e sobrepeso (19,39%);Entre 2 e 4 anos: obesidade (10,44%) e sobrepeso (18,87%);Abaixo de 2 anos: obesidade (11,88%) e sobrepeso (5,98%)</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"cozinha\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Cozinha comunit\u00e1ria</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 02 cozinhas comunit\u00e1rias custeadas pela prefeitura, com capacidade para preparar e distribuir aproximadamente 55 refei\u00e7\u00f5es diariamente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 105,00 em m\u00e9dia e atende um total aproximado de 100 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 2 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares em andamento.<br />\nS\u00e3o produtores que produzem principalmente:</p>\n<p>Agropecu\u00e1ria: milho, feij\u00e3o, melancia, jerimum, hortali\u00e7as e algumas \u00e1reas frut\u00edferas.<br />\nApicultura<br />\nPecu\u00e1ria. Bovino, caprino, ovinos, su\u00ednos e aves.<br />\nExtrativismo cera e a palha de carna\u00faba.</p>\n<p>Destes, 2021 possuem ativamente DAP &#8211; Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 16 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_42  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"central\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Central de Beneficiamento de Alimentos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Central de Beneficiamento de Alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 62.666 refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de 30 a 50% do or\u00e7amento recebido pelo PNAE e mais da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada duas vezes por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:10:16","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-3.6844057","%_wpgmp_metabox_longitude%":"-40.35617939999999","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:22:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"7\";i:3;s:1:\"8\";i:4;s:2:\"12\";i:5;s:2:\"17\";i:6;s:2:\"18\";i:7;s:2:\"19\";i:8;s:2:\"20\";i:9;s:2:\"22\";i:10;s:2:\"25\";i:11;s:2:\"29\";i:12;s:2:\"30\";i:13;s:2:\"31\";i:14;s:2:\"32\";i:15;s:2:\"33\";i:16;s:2:\"37\";i:17;s:2:\"38\";i:18;s:2:\"44\";i:19;s:2:\"45\";i:20;s:2:\"46\";i:21;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3ba1eaa32d0b6dd21875e7289425be35":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_f29ae0ea70caf672681adf0ea445f700":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8156e683614bff95cdef244f7b9d0c05":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_70a40745b44eeac1f59df327c2070e48":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_6239435dff688575c4951096b663874c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_3c086b84a60744d163cbedac9c66cb4e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_46de0ad5744aba0a28b04bf15a803c39":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_c8c8eacd5475c173d8bba4b7d74efa6d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_108ff824fd71c292d6571d452e37d745":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fb21a30ad4b920faa285dd563b873383":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_7352a25d42f823a4d80444302af4d227":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_198913d5173b779bb427062f43ad8868":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_bb75751ba0773f535532ff7ac206dcc9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_479d0c80d1f91ddc5971aa1c600455d7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_145ab8b15bc361b85e161e2aa64a2d4b":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_466b366a0c7c1eefeadaba21a944f956":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f50cf8f4436757e67b743fa23268d1f1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_f3a67b0f6b8f65a14c8fa6be6a2e2384":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_5839bdfef6eb01c40fd7eb28c91f8b76":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c4226bc7119dad3a431f9e3e9a4068e7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a79153d7ae7b080aca4fb75beab390b3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b7fbe7594654b4e39f29781a316adc98":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_85075cedb384483a421dabc52d1d7de5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d27d133f0154902764c6ac450f7bc35e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_87d8efa144f14befeebea078da18e385":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_25c67584596ed420c429a8c7d7977279":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_de70cb9a1e9d68457ac578512ff6a551":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_e0e54bdbcebb3a8f09e13e444cb88d9f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Semi\u00e1rido","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1063,"custom_filters":{"%regiao%":["Nordeste | Semi\u00e1rido"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Cozinha comunit\u00e1ria","id":"17","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Jo\u00e3o Pessoa","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nJo\u00e3o Pessoa <span class=\"fc-badge info\"></span></div>\r\n Para\u00edba, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/joao-pessoa/\">Ver mais</a></p></div>","content":"Para\u00edba, Brasil","location":{"lat":"-7.118835199999999","lng":"-34.8814339","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/joao-pessoa/","zoom":5,"extra_fields":{"post_excerpt":"Para\u00edba, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>825.796 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>210 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.joaopessoa.pb.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pb/joao-pessoa.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"five-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e Marcos Legais\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Frente Parlamentar de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#frente\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"558\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Cozinha comunit\u00e1ria\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#cozinha\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"775\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#refrigerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"871\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#ultraprocessados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"872\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2011.</strong></p>\n<p><strong>Lei n\u00b0 12.188, de 15 de setembro de 2011.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2004</strong>, com composi\u00e7\u00e3o de <strong>2/3</strong> da sociedade civil.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em <strong>2018</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em <strong>2015</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #frente\" module_id=\"frente\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"frente\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"667\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Frente Parlamentar de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Frente Parlamentar de SAN.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A 1\u00aa vers\u00e3o do Plano Municipal de SAN est\u00e1 em constru\u00e7\u00e3o.</p>\n<p>Sua elabora\u00e7\u00e3o conta com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de <strong>doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Existem <strong>2</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de <strong>2.750</strong> refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #cozinha\" module_id=\"cozinha\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"cozinha\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"786\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Cozinha comunit\u00e1ria</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Existem <strong>6</strong> cozinhas comunit\u00e1rias, com capacidade para preparar e distribuir um total de <strong>1.750</strong> refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui feiras agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio, existem feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerante\" module_id=\"itinerante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>\n<p>Tamb\u00e9m central estadual de abastecimento de alimentos, onde s\u00e3o <strong>comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o <strong>Festival do Milho e o Festival do Abacaxi</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas refei\u00e7\u00f5es diariamente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #refrigerantes\" module_id=\"refrigerantes\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"refrigerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"874\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei/decreto que pro\u00edbe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #ultraprocessados\" module_id=\"ultraprocessados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"ultraprocessados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"875\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei/decreto que pro\u00edbe ou limita a venda da venda de ultraprocessados nas escolas</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras <strong>em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>menos de</strong> <strong>30%do or\u00e7amento</strong> recebido pelo PNAE e <strong>menos da metade</strong> vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Jo\u00e3o Pessoa","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/joao-pessoa/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jo\u00e3o Pessoa\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_joao-pessoa-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275171:1","%_edit_last%":"1","%_thumbnail_id%":"745","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Jo\u00e3o Pessoa","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1050\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_26 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_32\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_51  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Jo\u00e3o Pessoa</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_27 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_52   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Jo\u00e3o Pessoa</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">825.796 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">210 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_83 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_84 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_53    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_28 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_34 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_35 five-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_55  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-uma-linha botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e Marcos Legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-uma-linha botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_29 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_56 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_57 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_58 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_59 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_60 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_61 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-456\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Frente Parlamentar de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_37 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_62 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_63 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_64 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_65 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-490\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Cozinha comunit\u00e1ria</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_66 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_67 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_38 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_68 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_69 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_70 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_71 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_72 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-460\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de refrigerante nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_73 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-459\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_39 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_74 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_75 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_76  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_77  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_78  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_79  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_80  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2011.<br />\nLei n\u00b0 12.188, de 15 de setembro de 2011.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_41\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_81  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2004, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_32 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_42\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_82  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em 2018.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_33 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_43\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_83  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em 2015</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_34 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_44\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_84  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"frente\" class=\"et_pb_section et_pb_section_35 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_45\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_85  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Frente Parlamentar de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Frente Parlamentar de SAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_46\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_86  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A 1\u00aa vers\u00e3o do Plano Municipal de SAN est\u00e1 em constru\u00e7\u00e3o.<br />\nSua elabora\u00e7\u00e3o conta com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_87  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_88  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 2 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de 2.750 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"cozinha\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_89  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Cozinha comunit\u00e1ria</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 6 cozinhas comunit\u00e1rias, com capacidade para preparar e distribuir um total de 1.750 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_50\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_90  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui feiras agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_41 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_91  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existem feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerante\" class=\"et_pb_section et_pb_section_42 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_52\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_92  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_43 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_93  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_126  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_44 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_54\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_94  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o Festival do Milho e o Festival do Abacaxi.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_95  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas refei\u00e7\u00f5es diariamente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"refrigerantes\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_56\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_96  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que pro\u00edbe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"ultraprocessados\" class=\"et_pb_section et_pb_section_47 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_57\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_97  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que pro\u00edbe ou limita a venda da venda de ultraprocessados nas escolas</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_48 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_98  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_49 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_59\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_99  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_144  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de menos de 30%do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_145  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:10:16","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_yoast_wpseo_content_score%":"60","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-7.118835199999999","%_wpgmp_metabox_longitude%":"-34.8814339","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:20:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:1:\"9\";i:6;s:2:\"10\";i:7;s:2:\"15\";i:8;s:2:\"16\";i:9;s:2:\"17\";i:10;s:2:\"19\";i:11;s:2:\"20\";i:12;s:2:\"21\";i:13;s:2:\"22\";i:14;s:2:\"23\";i:15;s:2:\"33\";i:16;s:2:\"34\";i:17;s:2:\"35\";i:18;s:2:\"37\";i:19;s:2:\"38\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3e8c3ce5e50dcd3ad9092b15b65b6baf":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_5fe453fd168a163dec2229dedd476895":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_b263baee0168a0c372bfdd3e189f1dd2":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_d22d3e200b4f38e5c2bd2b1b03b89202":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_01c952674e163b1e08401fa57e5e6034":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9b189568903d9875d4284e6bae40b733":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_6239435dff688575c4951096b663874c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_15d5a93135ffaaa2acbdca9ac945e548":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_7fbbf35cc66a7551dba30bc18fe7e75b":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_bb7b93f4babbe8edc5c951cf21bdcbeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_bbfb8c9c12477c7a24a408b03cea5518":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_68b5f8eb2216952580e41c6093b7845a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_64ed918eac00cafeba4c6dee51ac44a3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_056546f937824831dc0941827f0802cd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1ebe3b3be26177ce076c761c98c54925":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_bb75751ba0773f535532ff7ac206dcc9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_479d0c80d1f91ddc5971aa1c600455d7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_25c515a8c7c838cc5bf115b564771e49":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_fbe921604b5bfc09e35aa98db93b9f80":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_e5b69360a4f76fa7c21682275585ad96":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ac0cf0f282102f2545db00069dcf5aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f21f98a7e69347ea6a73c341610097e4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_ee2cffcc9a467259555b63bcb2caf0e6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1050,"custom_filters":{"%regiao%":["Nordeste | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Frente Parlamentar de SAN","id":"9","type":"category","extension_fields":{"cat_order":"6"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Cozinha comunit\u00e1ria","id":"17","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de refrigerantes nas escolas","id":"34","type":"category","extension_fields":{"cat_order":"31"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de ultraprocessados nas escolas","id":"35","type":"category","extension_fields":{"cat_order":"32"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}}]},{"source":"post","title":"Santar\u00e9m","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nSantar\u00e9m <span class=\"fc-badge info\"></span></div>\r\n Par\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/santarem/\">Ver mais</a></p></div>","content":"Par\u00e1, Brasil","location":{"lat":"-2.4406918","lng":"-54.7136192","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/santarem/","zoom":5,"extra_fields":{"post_excerpt":"Par\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>308.339 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>17.898 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://santarem.pa.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pa/santarem.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"six-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e Marcos Legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.25.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.25.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2015</strong>, com composi\u00e7\u00e3o de maioria da sociedade civil.<br />Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em <strong>2023.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio est\u00e1 em <strong>processo de formula\u00e7\u00e3o</strong> do plano municipal de SAN, sua elabora\u00e7\u00e3o est\u00e1 <strong>contando com a participa\u00e7\u00e3o da sociedade civil</strong>.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>Existe <strong>1</strong> restaurante popular custeado pela prefeitura, com capacidade para preparar e distribuir um total de <strong>300 refei\u00e7\u00f5es</strong> diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>No munic\u00edpio existem <strong>3</strong> feiras convencionais funcionando.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio existe mercado municipal onde s\u00e3o comercializados alimentos <strong>agroecol\u00f3gicos ou org\u00e2nicos</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como <strong>Festivais do a\u00e7a\u00ed, cupua\u00e7u, farinha e seus derivados</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem um percentual de <strong>50%</strong> do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>30 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa entre <strong>30% e 50%</strong> do or\u00e7amento recebido pelo PNAE e mais da metade vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Santar\u00e9m","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/santarem/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Santar\u00e9m\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_santarem-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703277259:1","%_edit_last%":"1","%_thumbnail_id%":"756","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Santar\u00e9m","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"7","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1043\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_50 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_61\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_100  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_146  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Santar\u00e9m</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_51 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_101   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_16 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_2 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Santar\u00e9m</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_11 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_8\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_18 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_149  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">308.339 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_12 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_20 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_150  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">17.898 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_13 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_21\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_10\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_22 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_151  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_14 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_23 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_152  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_153 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_154 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_102    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_52 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_63 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_103  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_155  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_64 six-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_104  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e Marcos Legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_13_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_13 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_14_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_14 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_15_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_15 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_16_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_16 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_17_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_17 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_53 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_65 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_105 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_106 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_43 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_107 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_44 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_108 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_45 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_109 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_46 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_110 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_47 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_66 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_111 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_48 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_112 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_49 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_113 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_50 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_114 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_51 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_115 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_52 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_116 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_53 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_67 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_117 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_118  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_119  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_120  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_121  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_122  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_54 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_68\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_123  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_156  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_157  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2015, com composi\u00e7\u00e3o de maioria da sociedade civil.Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_158  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_55 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_69\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_124  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_159  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_160  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em 2023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_161  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_56 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_70\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_125  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_162  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_163  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 em processo de formula\u00e7\u00e3o do plano municipal de SAN, sua elabora\u00e7\u00e3o est\u00e1 contando com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_164  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_57 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_71\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_126  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_165  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_166  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existe 1 restaurante popular custeado pela prefeitura, com capacidade para preparar e distribuir um total de 300 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_167  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_58 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_72\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_127  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_168  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_169  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_170  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_59 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_73\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_128  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_171  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_172  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existem 3 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_173  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_60 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_74\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_129  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_174  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_175  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_176  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_61 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_75\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_130  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_177  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_178  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como Festivais do a\u00e7a\u00ed, cupua\u00e7u, farinha e seus derivados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_179  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_62 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_76\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_131  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_180  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_181  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um percentual de 50% do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_182  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_63 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_77\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_132  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_183  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_184  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 30 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_185  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_64 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_78\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_133  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_186  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_187  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_188  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_65 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_79\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_134  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_189  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_190  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa entre 30% e 50% do or\u00e7amento recebido pelo PNAE e mais da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_191  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_66 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_80\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_135  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_192  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_193  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_194  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_67 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_81\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_136  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_195  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_196  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_197  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:10:16","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-2.4406918","%_wpgmp_metabox_longitude%":"-54.7136192","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:13:{i:0;s:1:\"5\";i:1;s:1:\"7\";i:2;s:2:\"10\";i:3;s:2:\"16\";i:4;s:2:\"19\";i:5;s:2:\"20\";i:6;s:2:\"22\";i:7;s:2:\"23\";i:8;s:2:\"24\";i:9;s:2:\"28\";i:10;s:2:\"32\";i:11;s:2:\"37\";i:12;s:2:\"38\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1043,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}}]},{"source":"post","title":"Bel\u00e9m","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nBel\u00e9m <span class=\"fc-badge info\"></span></div>\r\n Par\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/belem/\">Ver mais</a></p></div>","content":"Par\u00e1, Brasil","location":{"lat":"-1.4563432","lng":"-48.501299","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/belem/","zoom":5,"extra_fields":{"post_excerpt":"Par\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.506.420 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.059 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://prefeitura.belem.pa.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/pa/belem.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"six-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 500,00</strong> em m\u00e9dia e atende um total aproximado de <strong>28.000</strong> beneficiados.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>No munic\u00edpio existem feiras convencionais funcionando.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio existe mercado municipal onde s\u00e3o comercializados alimentos <strong>agroecol\u00f3gicos ou org\u00e2nicos</strong>.</div>\n<div>Tamb\u00e9m existe central estadual de abastecimento de alimentos.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>30 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas cerca de <strong>70 mil refei\u00e7\u00f5es por dia.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de <strong>30% do or\u00e7amento</strong> recebido pelo PNAE e <strong>menos da metade </strong>vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP-f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Bel\u00e9m","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/belem/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Bel\u00e9m\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_belem-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703273592:1","%_thumbnail_id%":"736","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Bel\u00e9m","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"5","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1030\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Bel\u00e9m</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Bel\u00e9m</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_populacao\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.506.420 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_quadro\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.059 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_pin\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 six-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras convencionais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=200%2C201&#038;ssl=1\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas escolares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=200%2C201&#038;ssl=1\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=200%2C201&#038;ssl=1\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=200%2C201&#038;ssl=1\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=200%2C201&#038;ssl=1\" alt=\"Controle de desmatamento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de compostagem\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_7\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_17  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 500,00 em m\u00e9dia e atende um total aproximado de 28.000 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_8\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_18  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existem feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_19  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_20  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 30 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a comunidade escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_21  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas cerca de 70 mil refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_22  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_23  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP-f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_24  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_25  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2024-07-24 20:55:21","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-1.4563432","%_wpgmp_metabox_longitude%":"-48.501299","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:9:{i:0;s:2:\"18\";i:1;s:2:\"19\";i:2;s:2:\"22\";i:3;s:2:\"28\";i:4;s:2:\"33\";i:5;s:2:\"37\";i:6;s:2:\"38\";i:7;s:2:\"45\";i:8;s:2:\"46\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1030,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}}]},{"source":"post","title":"Rio Branco","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nRio Branco <span class=\"fc-badge info\"></span></div>\r\n Acre, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/rio-branco/\">Ver mais</a></p></div>","content":"Acre, Brasil","location":{"lat":"-9.9740249","lng":"-67.8098191","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/rio-branco/","zoom":5,"extra_fields":{"post_excerpt":"Acre, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" hover_enabled=\"0\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" hover_enabled=\"0\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" sticky_enabled=\"0\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>419.452 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>8.835 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Amaz\u00f4nia Legal</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.riobranco.ac.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/ac/rio-branco.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Central de beneficiamento de alimentos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#central\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"587\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2020.</strong></p>\n<p><strong>Lei complementar n\u00b0 102 de 23 de dezembro de 2020</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2005</strong>, com composi\u00e7\u00e3o de <strong>2/3</strong> da sociedade civil.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2014</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2015</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias da <strong>Casa Civil, Secretaria de Planejamento, Secretaria de Sa\u00fade, De educa\u00e7\u00e3o, Agricultura, Meio Ambiente, Assist\u00eancia Social e Direitos Humanos, Articula\u00e7\u00e3o Comunit\u00e1ria, Secretaria Adjunta da Mulher e Coordenadoria do Trabalha e Economia Solid\u00e1ria.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos \u00e0 entidades cadastradas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>01</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de <strong>500 refei\u00e7\u00f5es</strong> diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>43</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado ou central de abastecimento municipal.</p>\n<p>Tamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>20 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>6 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #central\" module_id=\"central\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"central\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"686\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Central de Beneficiamento de Alimentos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Central de Beneficiamento de Alimentos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>30 a 50% do or\u00e7amento</strong> recebido pelo PNAE e <strong>mais da metade </strong>vem da produ\u00e7\u00e3o local.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este <strong>inclui emiss\u00f5es relacionadas aos sistemas alimentares</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Rio Branco","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/rio-branco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Rio Branco\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_rio-branco-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703276964:1","%_thumbnail_id%":"754","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Rio Branco","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"10","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"1021\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_68 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_83\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_137  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_198  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_199  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Rio Branco</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_69 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_138   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_24 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_3 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Rio Branco</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_200  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_16 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_25\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_12\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_26 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_201  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">419.452 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_17 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_27\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_28 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_202  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">8.835 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_18 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_29\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_14\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_30 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_203  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Amaz\u00f4nia Legal</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_19 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_31 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_204  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_205 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_206 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_139    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_15\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_70 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_85 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_140  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_207  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_86 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_141  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_18_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_18 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_19_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_19 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_20_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_20 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_21_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_21 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_22_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_22 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_23_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_23 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_24_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_24 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_71 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_87 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_142 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_54 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_143 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_55 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_144 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_56 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_145 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_57 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_146 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_58 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_147 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_59 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_88 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_148 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_60 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_149 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_61 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_150 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_62 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_151 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_63 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_152 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_64 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_153 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_65 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_89 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_154 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_66 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_155 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_67 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_156 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_68 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-454\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Central de beneficiamento de alimentos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_157 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_69 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_158 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_70 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_159 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_71 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_90 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_160 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_72 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_161 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_73 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_162 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_74 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_163 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_75 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_164  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_165  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_72 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_91\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_166  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_208  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_209  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2020.<br />\nLei complementar n\u00b0 102 de 23 de dezembro de 2020</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_210  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_73 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_92\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_167  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_211  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_212  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2005, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_213  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_74 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_93\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_168  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_214  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_215  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02014.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_216  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_75 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_94\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_169  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_217  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_218  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02015.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_219  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_76 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_95\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_170  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_220  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_221  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias da Casa Civil, Secretaria de Planejamento, Secretaria de Sa\u00fade, De educa\u00e7\u00e3o, Agricultura, Meio Ambiente, Assist\u00eancia Social e Direitos Humanos, Articula\u00e7\u00e3o Comunit\u00e1ria, Secretaria Adjunta da Mulher e Coordenadoria do Trabalha e Economia Solid\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_222  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_77 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_96\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_171  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_223  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_224  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos \u00e0 entidades cadastradas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_225  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_78 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_97\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_172  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_226  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_227  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 01 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de 500 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_228  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_79 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_98\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_173  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_229  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_230  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_231  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_80 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_99\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_174  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_232  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_233  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 43 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_234  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_81 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_100\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_175  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_235  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_236  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado ou central de abastecimento municipal.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_237  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_82 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_101\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_176  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_238  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_239  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_240  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_83 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_102\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_177  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_241  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_242  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_243  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_84 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_103\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_178  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_244  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_245  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 20 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_246  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_85 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_104\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_179  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_247  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_248  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 6 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_249  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"central\" class=\"et_pb_section et_pb_section_86 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_105\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_180  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_250  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Central de Beneficiamento de Alimentos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_251  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Central de Beneficiamento de Alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_252  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_87 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_106\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_181  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_253  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_254  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_255  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_88 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_107\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_182  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_256  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_257  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de 30 a 50% do or\u00e7amento recebido pelo PNAE e mais da metade vem da produ\u00e7\u00e3o local.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_258  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_89 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_108\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_183  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_259  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_260  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_261  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_90 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_109\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_184  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_262  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_263  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_264  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_91 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_110\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_185  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_265  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_266  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_267  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_92 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_111\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_186  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_268  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_269  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_270  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_93 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_112\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_187  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_271  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_272  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_273  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:10:17","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_yoast_wpseo_content_score%":"60","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-9.9740249","%_wpgmp_metabox_longitude%":"-67.8098191","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:22:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"15\";i:6;s:2:\"16\";i:7;s:2:\"19\";i:8;s:2:\"20\";i:9;s:2:\"22\";i:10;s:2:\"23\";i:11;s:2:\"27\";i:12;s:2:\"28\";i:13;s:2:\"29\";i:14;s:2:\"32\";i:15;s:2:\"37\";i:16;s:2:\"38\";i:17;s:2:\"40\";i:18;s:2:\"42\";i:19;s:2:\"44\";i:20;s:2:\"45\";i:21;s:2:\"46\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Amaz\u00f4nia Legal","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":1021,"custom_filters":{"%regiao%":["Amaz\u00f4nia Legal"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa","id":"42","type":"category","extension_fields":{"cat_order":"39"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}}]},{"source":"post","title":"Petrolina","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nPetrolina <span class=\"fc-badge info\"></span></div>\r\n Pernambuco, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/petrolina/\">Ver mais</a></p></div>","content":"Pernambuco, Brasil","location":{"lat":"-9.3994602","lng":"-40.5023565","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/petrolina/","zoom":5,"extra_fields":{"post_excerpt":"Pernambuco, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>359.372 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>4.561 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Semi\u00e1rido</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.prefeituradepetrolina.org/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/pe/petrolina.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"five-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e Marcos Legais\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui COMSEA, com composi\u00e7\u00e3o <strong>majorit\u00e1ria da sociedade civil</strong>.</div>\n<div>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em <strong>2015</strong>.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<p>Os percentuais de obesidade na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>19%</strong></p>\n<p>Entre 13 e 17 anos: <strong>11%</strong></p>\n<p>Entre 10 e 12 anos: <strong>27%</strong></p>\n<p>Entre 5 e 9 anos: <strong>4%</strong></p>\n<p>Entre 2 e 4 anos: <strong>4%</strong></p>\n<p>Abaixo de 2 anos: <strong>5%</strong></p>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>Existe <strong>1</strong> restaurante popular, com capacidade para preparar e distribuir um total de <strong>1.100</strong> refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 250,00</strong> e atende um total aproximado de <strong>2.000</strong> beneficiados.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio, existem <strong>5</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerante\" module_id=\"itinerante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui feira itinerante com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados poucos alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o \"Festival Gastron\u00f4mico de Petrolina\".</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>uma vez</strong> por semana no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Petrolina","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/petrolina/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Petrolina\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_petrolina-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703276320:1","%_edit_last%":"1","%_thumbnail_id%":"752","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Petrolina","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"996\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Petrolina</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Petrolina</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">359.372 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">4.561 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Semi\u00e1rido</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 five-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-uma-linha botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e Marcos Legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-uma-linha botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_8\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_23  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA, com composi\u00e7\u00e3o majorit\u00e1ria da sociedade civil.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_24  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em 2015.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_25  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: 19%<br />\nEntre 13 e 17 anos: 11%<br />\nEntre 10 e 12 anos: 27%<br />\nEntre 5 e 9 anos: 4%<br />\nEntre 2 e 4 anos: 4%<br />\nAbaixo de 2 anos: 5%</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_26  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existe 1 restaurante popular, com capacidade para preparar e distribuir um total de 1.100 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_28  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 250,00 e atende um total aproximado de 2.000 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_29  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_30  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existem 5 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerante\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_31  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui feira itinerante com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_32  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados poucos alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_33  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o &#8220;Festival Gastron\u00f4mico de Petrolina&#8221;.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada uma vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-05 23:14:44","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-9.3994602","%_wpgmp_metabox_longitude%":"-40.5023565","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:13:{i:0;s:1:\"5\";i:1;s:1:\"7\";i:2;s:2:\"12\";i:3;s:2:\"14\";i:4;s:2:\"16\";i:5;s:2:\"18\";i:6;s:2:\"19\";i:7;s:2:\"20\";i:8;s:2:\"21\";i:9;s:2:\"22\";i:10;s:2:\"23\";i:11;s:2:\"45\";i:12;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_4db86d65fcc46c5d8c083f7b24ec314d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_5f9a1b921ad14c22d726d6e04a597691":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_b263baee0168a0c372bfdd3e189f1dd2":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_d22d3e200b4f38e5c2bd2b1b03b89202":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_01c952674e163b1e08401fa57e5e6034":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_2dbb4028c9bd1202d4fcb55bf045b12b":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_70a40745b44eeac1f59df327c2070e48":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8a19a379ad70facb592c17bbccebb64d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3c086b84a60744d163cbedac9c66cb4e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_15d5a93135ffaaa2acbdca9ac945e548":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_68b5f8eb2216952580e41c6093b7845a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ee8e69706d13f04f76e0196fb5942e03":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1986162cb179633fb012dcb18b4c3d27":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_145ab8b15bc361b85e161e2aa64a2d4b":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_466b366a0c7c1eefeadaba21a944f956":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_25c515a8c7c838cc5bf115b564771e49":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_fbe921604b5bfc09e35aa98db93b9f80":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Semi\u00e1rido","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":996,"custom_filters":{"%regiao%":["Nordeste | Semi\u00e1rido"],"%tema%":["Abastecimento e Acesso a Alimentos","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Jundia\u00ed","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nJundia\u00ed <span class=\"fc-badge info\"></span></div>\r\n S\u00e3o Paulo, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/jundiai/\">Ver mais</a></p></div>","content":"S\u00e3o Paulo, Brasil","location":{"lat":"-23.1856699","lng":"-46.8892603","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/jundiai/","zoom":5,"extra_fields":{"post_excerpt":"S\u00e3o Paulo, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>426.935 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>431.204 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://jundiai.sp.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/sp/jundiai.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivo Fiscal\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em <strong>2023</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>\n<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>Obesidade 23,2% e soprepeso 31,41%</strong><br />Entre 13 e 17 anos: <strong>Obesidade 16,47% e sobrepeso 22,22%</strong><br />Entre 4 e 9 anos: <strong>Obesidade 11,43% e sobrepeso 16,13%</strong><br />Abaixo de 2 anos: <strong>Obesidade 7,16%</strong></p>\n</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>2</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.25.1\" _module_preset=\"default\" text_font=\"|300|||||||\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>No munic\u00edpio, existem <strong>32</strong> feiras convencionais funcionando.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como a <strong>Festa da Uva, Festa Italiana, Festa Portuguesa</strong>.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio tem um percentual de <strong>33%</strong> do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>102</strong> escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 secretaria de meio ambiente ou de educa\u00e7\u00e3o.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>7</strong> hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico/org\u00e2nico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do <strong>espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>140.000</strong> refei\u00e7\u00f5es por dia.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa <strong>menos de 30%</strong> do or\u00e7amento recebido pelo PNAE e <strong>menos da metade</strong> vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa <strong>38,47%</strong> em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este <strong>inclui emiss\u00f5es relacionadas aos sistemas alimentares</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>2 vezes por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Jundia\u00ed","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/jundiai/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Jundia\u00ed\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_osasco-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275420:1","%_thumbnail_id%":"750","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Jundia\u00ed","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"11","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"985\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_17 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Jundia\u00ed</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_18 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_37   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Jundia\u00ed</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">426.935 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">431.204 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_38    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_19 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_25 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-uma-linha botao-filtros-cidades df-button dfc-incentivo et_pb_bg_layout_light\" href=\"\">Incentivo Fiscal</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_20 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_41 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_42 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_43 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_44 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_45 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_46 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_27 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_47 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_48 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_49 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_50 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_51 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_52 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_28 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_53 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_54 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_55 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_56 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_57 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_58 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_29 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_59 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_60 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_61 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_62 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_63 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_64 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_65  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_66  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em 2023.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_32\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_67  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: Obesidade 23,2% e soprepeso 31,41%Entre 13 e 17 anos: Obesidade 16,47% e sobrepeso 22,22%Entre 4 e 9 anos: Obesidade 11,43% e sobrepeso 16,13%Abaixo de 2 anos: Obesidade 7,16%</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_68  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 2 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_34\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_69  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existem 32 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_26 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_70  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como a Festa da Uva, Festa Italiana, Festa Portuguesa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_27 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_71  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um percentual de 33% do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_28 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_37\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_72  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_38\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_73  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_39\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_74  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 102 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 secretaria de meio ambiente ou de educa\u00e7\u00e3o.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_75  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 7 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_32 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_41\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_76  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_33 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_42\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_77  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 140.000 refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_34 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_43\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_78  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_35 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_44\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_79  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_45\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_80  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 38,47% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_46\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_81  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_82  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_83  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_84  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada 2 vezes por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-05 23:14:45","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-23.1856699","%_wpgmp_metabox_longitude%":"-46.8892603","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:23:{i:0;s:1:\"5\";i:1;s:1:\"7\";i:2;s:2:\"12\";i:3;s:2:\"15\";i:4;s:2:\"19\";i:5;s:2:\"20\";i:6;s:2:\"23\";i:7;s:2:\"24\";i:8;s:2:\"26\";i:9;s:2:\"27\";i:10;s:2:\"28\";i:11;s:2:\"29\";i:12;s:2:\"30\";i:13;s:2:\"33\";i:14;s:2:\"37\";i:15;s:2:\"38\";i:16;s:2:\"39\";i:17;s:2:\"40\";i:18;s:2:\"42\";i:19;s:2:\"44\";i:20;s:2:\"45\";i:21;s:2:\"47\";i:22;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_ca8549014f5583ea6c7cdbd04af5c7ad":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_7dd3158bbe299b3658661f54b3e1987e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_23517a7084550c305a833d75c090cdab":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_019ebbc70bf13fb4c696915bd20bdcb8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_012a5040d0af8a3bcf40849ff8baaa12":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_c8c8eacd5475c173d8bba4b7d74efa6d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_cee412bcabe1b1d9f41c5e486abd4e85":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_2b5e35d4a97f3e0bee3bb0dffd29c50f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_977b90a6fb8e7f37ae43cd20cd918cc9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_783800b43f0e4abf344e603dbbb3fcd6":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3d169557b8089f60f0bc76cf00869f7e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8339c572ad7b20082abe93299f01b817":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_7352a25d42f823a4d80444302af4d227":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_cc43e576b2891948f07b4a4e0202d3dc":{"bosh":true,"pos":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_4a22aa923a59f8b9ff816c1289d81e85":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_019c87ba3477d565f24c4f3ebab88426":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b4323ea9a276e75160ae253dded76af2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ff2fda3ad65195e7a48ebbd33f02e411":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_926915f01c59231473997dd9cfe8e7cf":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a81f5ba9e8c18b56e910512764f5e4c4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1a3f67adef4aa6d9a16ccd98e9aa1d2a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4d1a336505729a06e3f973fafcea54ea":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f0fce30a74acf0475a1240d8b721cc0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_5839bdfef6eb01c40fd7eb28c91f8b76":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c4226bc7119dad3a431f9e3e9a4068e7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4a05a17bb0504c5cd1cacca1d674db05":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_220c4d5e8f37bc9b0c4035dedbbebb7a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a071358de769b683d941974803ce07d3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_33f7b40f7c3c3a952ce26076f37a9399":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_87d8efa144f14befeebea078da18e385":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_25c67584596ed420c429a8c7d7977279":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_6486c5461704c82b2277867c8aaa9a1c":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Incentivo Fiscal, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":985,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Incentivo Fiscal","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa","id":"42","type":"category","extension_fields":{"cat_order":"39"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]},{"source":"post","title":"Pindamonhangaba","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nPindamonhangaba <span class=\"fc-badge info\"></span></div>\r\n S\u00e3o Paulo, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/pindamonhangaba/\">Ver mais</a></p></div>","content":"S\u00e3o Paulo, Brasil","location":{"lat":"-22.9263928","lng":"-45.4620404","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/pindamonhangaba/","zoom":5,"extra_fields":{"post_excerpt":"S\u00e3o Paulo, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>171.885 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>731.355 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://pindamonhangaba.sp.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/sp/pindamonhangaba.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"five-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pagamentos por Servi\u00e7os Ambientais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pagamentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"782\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>3</strong> feiras agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio, existem <strong>2</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados poucos alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos mensalmente.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>25 mil</strong> refei\u00e7\u00f5es por dia.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras <strong>em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>menos de</strong> <strong>30%do or\u00e7amento</strong> recebido pelo PNAE e <strong>menos da metade</strong> vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pagamentos\" module_id=\"pagamentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pagamentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"795\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>uma vez</strong> por semana no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Pindamonhangaba","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/pindamonhangaba/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Pindamonhangaba\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_osasco-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703276418:1","%_thumbnail_id%":"750","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Pindamonhangaba","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"6","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"974\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_41 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_85  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Pindamonhangaba</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_42 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_86   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_16 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_2 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Pindamonhangaba</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_11 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_8\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_18 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">171.885 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_12 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_20 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">731.355 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_13 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_21\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_10\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_22 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_14 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_23 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_126 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_87    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_43 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_88  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_54 five-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_89  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_13_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_13 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_14_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_14 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_15_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_15 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_16_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_16 botao-uma-linha botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_17_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_17 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_44 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_90 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_91 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_92 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_93 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_94 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_95 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_56 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_96 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_97 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_98 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_99 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-485\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pagamentos por Servi\u00e7os Ambientais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_100 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_43 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_101 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_44 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_57 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_102 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_103  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_104  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_105  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_106  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_107  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_108  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 3 feiras agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_59\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_109  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existem 2 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_47 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_60\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_110  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados poucos alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_48 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_61\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_111  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos mensalmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_49 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_62\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_112  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_50 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_63\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_113  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_144  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_145  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 25 mil refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_146  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_51 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_64\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_114  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_149  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_52 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_65\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_115  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_150  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_151  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de menos de 30%do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_152  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pagamentos\" class=\"et_pb_section et_pb_section_53 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_66\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_116  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_153  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_154  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_155  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_54 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_67\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_117  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_156  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_157  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_158  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_55 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_68\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_118  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_159  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_160  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_161  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_56 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_69\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_119  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_162  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_163  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada uma vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_164  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-05 23:14:45","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_yoast_wpseo_content_score%":"60","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-22.9263928","%_wpgmp_metabox_longitude%":"-45.4620404","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:13:{i:0;s:2:\"19\";i:1;s:2:\"20\";i:2;s:2:\"22\";i:3;s:2:\"23\";i:4;s:2:\"26\";i:5;s:2:\"29\";i:6;s:2:\"33\";i:7;s:2:\"37\";i:8;s:2:\"38\";i:9;s:2:\"41\";i:10;s:2:\"45\";i:11;s:2:\"46\";i:12;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_91b836d550e50a424e2f72d0aaa3e64e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_7a2459b35c8ba1869c1e24fffc793ad9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_b263baee0168a0c372bfdd3e189f1dd2":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_2dbb4028c9bd1202d4fcb55bf045b12b":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_acce4e24add742dbbec7c4bdc245a6e4":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_2b5e35d4a97f3e0bee3bb0dffd29c50f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_783800b43f0e4abf344e603dbbb3fcd6":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_699e7e4a490cec8d44f209ef49562625":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_198913d5173b779bb427062f43ad8868":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b4323ea9a276e75160ae253dded76af2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a81f5ba9e8c18b56e910512764f5e4c4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1a3f67adef4aa6d9a16ccd98e9aa1d2a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f2673c7ff33c70c90d10e926397caefd":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d86b7944a72648aad2b02206e0c82c1a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_de70cb9a1e9d68457ac578512ff6a551":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_e0e54bdbcebb3a8f09e13e444cb88d9f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_6486c5461704c82b2277867c8aaa9a1c":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Subtropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":974,"custom_filters":{"%regiao%":["Centro-Sul | Subtropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Nova Lima","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nNova Lima <span class=\"fc-badge info\"></span></div>\r\n Minas Gerais, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/nova-lima/\">Ver mais</a></p></div>","content":"Minas Gerais, Brasil","location":{"lat":"-19.9849058","lng":"-43.8469634","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/nova-lima/","zoom":5,"extra_fields":{"post_excerpt":"Minas Gerais, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>97.378 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>429.331 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://novalima.mg.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/mg/nova-lima.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mapeamento\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2021.</strong></p>\n<p><strong>Lei Municipal 2888 de 23/12/2021.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"][/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>Obesidade 40,71% e sobrepeso 36,86%</strong><br />Entre 10 e 12 anos: <strong>Obesidade 17,21% e sobrepeso 21,40%</strong><br />Entre 4 e 9 anos: <strong>Obesidade 12,58% e sobrepeso 17,86%</strong><br />Entre 2 e 4 anos: <strong>Obesidade 3,08% e sobrepeso 5,07%</strong><br />Abaixo de 2 anos: <strong>Obesidade 1,89% e sobrepeso 6,59%</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 121,00 a R$ 606,00</strong> - de acordo com o perfil da fam\u00edlia, e atende um total aproximado de <strong>1.192</strong> fam\u00edlias beneficiadas.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de <strong>alimentos agroecol\u00f3gicos/org\u00e2nicos.</strong></div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerante\" module_id=\"itinerante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>\n<p>Tamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o <strong>Festival de cerveja artesanal (Uaiktoberfest), Festa da Mandioca, Rota dos Sabores (festival realizado com bares e restaurantes da cidade - cada um desenvolve um prato espec\u00edfico para o evento e os consumidores julgam durante o tempo que o festival durar), Prove e aprove (desenvolvido no \u00e2mbito da PNAE)</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares feito <strong>mensalmente</strong>.</p>\n<p>S\u00e3o <strong>350</strong> produtores que produzem principalmente <strong>Hortali\u00e7as, fruticultura, oler\u00edcola, produ\u00e7\u00e3o de pequenos animais, produtos processados, sais arom\u00e1ticos, charcutaria, defumados, mel, pr\u00f3polis e quitandas</strong>.</p>\n<p>Destes, <strong>9</strong> possuem DAP - Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>3</strong> escolas possuem hortas.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 <strong>a dire\u00e7\u00e3o da escola, a comunidade escolar e a secretaria de meio ambiente e educa\u00e7\u00e3o</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>3 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>16.850</strong> refei\u00e7\u00f5es por dia.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong> e em <strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de <strong>30% do or\u00e7amento</strong> recebido pelo PNAE e <strong>menos da metade </strong>vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsical).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra de produtos org\u00e2nicos ou agroecol\u00f3gicos representa <strong>5%</strong> em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>uma vez por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Nova Lima","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/nova-lima/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Nova Lima\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_osasco-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275986:1","%_thumbnail_id%":"750","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Nova Lima","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"957\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_57 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_71\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_120  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_165  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_166  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nova Lima</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_58 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_121   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_24 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_3 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Nova Lima</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_167  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_16 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_25\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_12\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_26 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_168  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">97.378 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_17 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_27\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_28 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_169  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">429.331 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_18 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_29\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_14\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_30 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_170  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_19 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_31 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_171  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_172 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_173 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_122    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_15\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_59 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_73 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_123  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_174  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_74 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_124  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_18_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_18 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_19_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_19 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_20_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_20 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_21_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_21 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_22_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_22 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_23_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_23 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_24_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_24 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_60 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_75 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_125 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_45 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_126 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_46 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_127 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_47 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_128 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_48 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_129 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_49 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_130 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_50 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_76 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_131 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_51 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_132 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_52 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_133 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_53 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_134 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_54 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_135 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_55 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_136 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_56 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_77 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_137 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_57 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_138 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_58 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_139 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_59 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_140 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_60 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_141 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_61 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_142 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_62 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_61 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_78\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_143  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_175  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_176  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2021.<br />\nLei Municipal 2888 de 23/12/2021.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_177  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_62 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_79\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_144  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_178  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_179  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_180  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_63 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_80\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_145  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_181  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_182  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: Obesidade 40,71% e sobrepeso 36,86%Entre 10 e 12 anos: Obesidade 17,21% e sobrepeso 21,40%Entre 4 e 9 anos: Obesidade 12,58% e sobrepeso 17,86%Entre 2 e 4 anos: Obesidade 3,08% e sobrepeso 5,07%Abaixo de 2 anos: Obesidade 1,89% e sobrepeso 6,59%</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_183  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_64 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_81\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_146  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_184  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_185  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 121,00 a R$ 606,00 &#8211; de acordo com o perfil da fam\u00edlia, e atende um total aproximado de 1.192 fam\u00edlias beneficiadas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_186  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_65 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_82\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_147  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_187  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_188  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_189  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_66 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_83\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_148  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_190  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_191  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_192  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerante\" class=\"et_pb_section et_pb_section_67 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_84\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_149  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_193  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_194  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_195  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_68 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_85\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_150  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_196  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_197  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o Festival de cerveja artesanal (Uaiktoberfest), Festa da Mandioca, Rota dos Sabores (festival realizado com bares e restaurantes da cidade &#8211; cada um desenvolve um prato espec\u00edfico para o evento e os consumidores julgam durante o tempo que o festival durar), Prove e aprove (desenvolvido no \u00e2mbito da PNAE).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_198  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_69 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_86\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_151  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_199  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_200  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares feito mensalmente.<br />\nS\u00e3o 350 produtores que produzem principalmente Hortali\u00e7as, fruticultura, oler\u00edcola, produ\u00e7\u00e3o de pequenos animais, produtos processados, sais arom\u00e1ticos, charcutaria, defumados, mel, pr\u00f3polis e quitandas.<br />\nDestes, 9 possuem DAP &#8211; Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_201  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_70 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_87\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_152  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_202  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_203  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 3 escolas possuem hortas.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola, a comunidade escolar e a secretaria de meio ambiente e educa\u00e7\u00e3o.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_204  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_71 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_88\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_153  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_205  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_206  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 3 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_207  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_72 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_89\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_154  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_208  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_209  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_210  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_73 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_90\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_155  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_211  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_212  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 16.850 refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_213  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_74 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_91\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_156  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_214  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_215  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_216  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_75 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_92\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_157  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_217  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_218  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsical).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_219  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_76 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_93\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_158  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_220  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_221  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra de produtos org\u00e2nicos ou agroecol\u00f3gicos representa 5% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_222  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_77 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_94\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_159  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_223  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_224  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_225  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_78 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_95\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_160  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_226  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_227  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada uma vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_228  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-05 23:14:45","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-19.9849058","%_wpgmp_metabox_longitude%":"-43.8469634","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:17:{i:0;s:1:\"4\";i:1;s:1:\"8\";i:2;s:2:\"12\";i:3;s:2:\"19\";i:4;s:2:\"20\";i:5;s:2:\"21\";i:6;s:2:\"23\";i:7;s:2:\"25\";i:8;s:2:\"28\";i:9;s:2:\"29\";i:10;s:2:\"30\";i:11;s:2:\"33\";i:12;s:2:\"37\";i:13;s:2:\"38\";i:14;s:2:\"39\";i:15;s:2:\"45\";i:16;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_6f361a15dd679933e8ab64dfae1c257c":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_82f099fab7d62aff57215e0798849738":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_70a40745b44eeac1f59df327c2070e48":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3c086b84a60744d163cbedac9c66cb4e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_15d5a93135ffaaa2acbdca9ac945e548":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_46de0ad5744aba0a28b04bf15a803c39":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_c8c8eacd5475c173d8bba4b7d74efa6d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3d169557b8089f60f0bc76cf00869f7e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_145ab8b15bc361b85e161e2aa64a2d4b":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_466b366a0c7c1eefeadaba21a944f956":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_25c515a8c7c838cc5bf115b564771e49":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_fbe921604b5bfc09e35aa98db93b9f80":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f50cf8f4436757e67b743fa23268d1f1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_f3a67b0f6b8f65a14c8fa6be6a2e2384":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_5839bdfef6eb01c40fd7eb28c91f8b76":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c4226bc7119dad3a431f9e3e9a4068e7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4a05a17bb0504c5cd1cacca1d674db05":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_220c4d5e8f37bc9b0c4035dedbbebb7a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Subtropical","taxonomy=tema":""},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":957,"custom_filters":{"%regiao%":["Centro-Sul | Subtropical"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Araraquara","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nAraraquara <span class=\"fc-badge info\"></span></div>\r\n S\u00e3o Paulo, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/araraquara/\">Ver mais</a></p></div>","content":"S\u00e3o Paulo, Brasil","location":{"lat":"-21.7790843","lng":"-48.1792643","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/araraquara/","zoom":5,"extra_fields":{"post_excerpt":"S\u00e3o Paulo, Brasil","post_content":"<!-- wp:divi/placeholder -->\n[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>240.542 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.003 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.araraquara.sp.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/sp/araraquara.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivo Fiscal\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Central de beneficiamento de alimentos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#central\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"587\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mapeamento\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivos fiscais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"601\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Incentivo Fiscal</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN\u00a0<strong>desde 2007.</strong></p>\n<p><strong>Lei Municipal n\u00ba 9.147 de 06/12/2017.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de<strong> desde 2017</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.<br />A presid\u00eancia \u00e9 ocupada por representante da prefeitura e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2018</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias <strong>Assist\u00eancia Social - Trabalho e Desenvolvimento Econ\u00f4mico - Sa\u00fade - Esportes - Participa\u00e7\u00e3o Popular - Desenvolvimento Urbano - DAAE</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela secretaria de <strong>Assist\u00eancia Social</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de <strong>2018</strong>.</p>\n<p>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de <strong>doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>2</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir <strong>260 refei\u00e7\u00f5es</strong> diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui programa de transfer\u00eancia de renda.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feira agroecol\u00f3gica e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>06</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos bimestralmente, como <strong>Culin\u00e1ria Afetiva e Receitas com PANCS</strong>.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #central\" module_id=\"central\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"central\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"686\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Central de Beneficiamento de Alimentos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Central de Beneficiamento de Alimentos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares. S\u00e3o <strong>407 produtores</strong> que produzem principalmente <strong>soja, milho, cana de a\u00e7\u00facar, hortali\u00e7as</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>2 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de <strong>uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa entre <strong>30% e 50% do or\u00e7amento</strong> recebido pelo PNAE e <strong>metade vem da produ\u00e7\u00e3o local</strong>.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>duas vezes por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivos\" module_id=\"incentivos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivos fiscais</h5>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"707\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>INCENTIVO FISCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]\n<!-- /wp:divi/placeholder -->","post_title":"Araraquara","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/araraquara/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Araraquara\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_araraquara-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1708094886:1","%_thumbnail_id%":"734","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Araraquara","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"12","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"945\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_79 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_97\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_161  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_229  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_230  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Araraquara</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_80 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_162   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_32 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_4 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Araraquara</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_231  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_21 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_33\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_16\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_34 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_232  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">240.542 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_22 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_35\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_36 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_233  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.003 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_23 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_37\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_18\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_38 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_234  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_24 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_39 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_235  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_236 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_237 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_163    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_81 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_99 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_164  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_238  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_100 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_165  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_25_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_25 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_26_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_26 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_27_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_27 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_28_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_28 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_29_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_29 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_30_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_30 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_31_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_31 botao-uma-linha botao-filtros-cidades df-button dfc-incentivo et_pb_bg_layout_light\" href=\"\">Incentivo Fiscal</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_32_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_32 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_82 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_101 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_166 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_63 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_167 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_64 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_168 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_65 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_169 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_66 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_170 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_67 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_171 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_68 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_102 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_172 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_69 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_173 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_70 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_174 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_71 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_175 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_72 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_176 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_73 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_177 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_74 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_103 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_178 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_75 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_179 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_76 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-454\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Central de beneficiamento de alimentos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_180 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_77 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_181 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_78 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_182 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_79 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_183 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_80 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_104 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_184 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_81 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_185 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_82 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_186 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_83 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_187 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_84 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_188 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_85 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_189 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_86 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_105 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_190 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_87 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_191 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_88 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-479\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivos fiscais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Incentivo Fiscal</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_192  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_193  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_194  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_195  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_83 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_106\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_196  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_239  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_240  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN\u00a0desde 2007.<br />\nLei Municipal n\u00ba 9.147 de 06/12/2017.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_241  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_84 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_107\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_197  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_242  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_243  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de desde 2017, com composi\u00e7\u00e3o de 2/3 da sociedade civil.A presid\u00eancia \u00e9 ocupada por representante da prefeitura e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_244  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_85 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_108\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_198  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_245  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_246  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02018.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_247  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_86 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_109\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_199  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_248  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_249  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_250  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_87 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_110\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_200  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_251  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_252  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias Assist\u00eancia Social &#8211; Trabalho e Desenvolvimento Econ\u00f4mico &#8211; Sa\u00fade &#8211; Esportes &#8211; Participa\u00e7\u00e3o Popular &#8211; Desenvolvimento Urbano &#8211; DAAE.<br />\nA presid\u00eancia \u00e9 exercida pela secretaria de Assist\u00eancia Social.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_253  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_88 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_111\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_201  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_254  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_255  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de 2018.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_256  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_89 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_112\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_202  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_257  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_258  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_259  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_90 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_113\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_203  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_260  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_261  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_262  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_91 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_114\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_204  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_263  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_264  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 2 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir 260 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_265  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_92 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_115\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_205  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_266  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_267  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de transfer\u00eancia de renda.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_268  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_93 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_116\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_206  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_269  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_270  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feira agroecol\u00f3gica e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_271  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_94 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_117\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_207  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_272  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_273  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 06 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_274  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_95 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_118\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_208  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_275  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_276  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos bimestralmente, como Culin\u00e1ria Afetiva e Receitas com PANCS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_277  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"central\" class=\"et_pb_section et_pb_section_96 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_119\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_209  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_278  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Central de Beneficiamento de Alimentos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_279  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Central de Beneficiamento de Alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_280  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_97 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_120\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_210  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_281  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_282  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_283  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_98 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_121\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_211  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_284  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_285  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares. S\u00e3o 407 produtores que produzem principalmente soja, milho, cana de a\u00e7\u00facar, hortali\u00e7as.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_286  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_99 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_122\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_212  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_287  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_288  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_289  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_100 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_123\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_213  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_290  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_291  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 2 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_292  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_101 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_124\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_214  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_293  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_294  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_295  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_102 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_125\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_215  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_296  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_297  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_298  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_103 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_126\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_216  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_299  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_300  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa entre 30% e 50% do or\u00e7amento recebido pelo PNAE e metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_301  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_104 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_127\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_217  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_302  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_303  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_304  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_105 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_128\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_218  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_305  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_306  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_307  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_106 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_129\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_219  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_308  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_309  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_310  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_107 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_130\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_220  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_311  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_312  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada duas vezes por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_313  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivos\" class=\"et_pb_section et_pb_section_108 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_131\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_221  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_314  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Incentivos fiscais</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_315  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_316  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>INCENTIVO FISCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-05 23:14:46","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-21.7790843","%_wpgmp_metabox_longitude%":"-48.1792643","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:26:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"14\";i:7;s:2:\"15\";i:8;s:2:\"16\";i:9;s:2:\"18\";i:10;s:2:\"19\";i:11;s:2:\"20\";i:12;s:2:\"23\";i:13;s:2:\"25\";i:14;s:2:\"26\";i:15;s:2:\"27\";i:16;s:2:\"29\";i:17;s:2:\"30\";i:18;s:2:\"32\";i:19;s:2:\"37\";i:20;s:2:\"38\";i:21;s:2:\"40\";i:22;s:2:\"45\";i:23;s:2:\"46\";i:24;s:2:\"47\";i:25;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_last_editor_used_jetpack%":"block-editor","%um_content_restriction%":", 0, , 0, 0, , 0, ","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Incentivo Fiscal, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":945,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Incentivo Fiscal","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]},{"source":"post","title":"Osasco","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nOsasco <span class=\"fc-badge info\"></span></div>\r\n S\u00e3o Paulo, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/osasco/\">Ver mais</a></p></div>","content":"S\u00e3o Paulo, Brasil","location":{"lat":"-23.5326334","lng":"-46.7915243","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/osasco/","zoom":5,"extra_fields":{"post_excerpt":"S\u00e3o Paulo, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>701.428 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>64.954 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://osasco.sp.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/sp/osasco.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"six-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2006</strong>.</p>\n<p><strong>Lei Municipal n\u00ba 4.842, de 30 de outubro de 2017. Decreto Municipal n\u00ba 9.633, de 17 de agosto de 2006, Lei Municipal n\u00ba 4.002, de 16 de fevereiro de 2006, Lei Municipal n\u00ba 4.577, de 05 de julho de 2013, Lei Municipal n\u00ba 4.640, de 12 de junho de 2014, Decreto Municipal n\u00ba 11.106, de 14 de maio de 2015, Lei Municipal n\u00ba 4.886, de 29 de maio de 2018, Decreto Municipal n\u00ba 11.729, de 12 de julho de 2018, Lei Municipal n\u00ba 4.936, de 28 de dezembro de 2018. Lei Municipal n\u00ba 5.155, de 10 de dezembro de 2021. Lei Municipal n\u00ba 5.157, de 15 de dezembro de 2021</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado<strong> desde 2006</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de <strong>processo eleitoral ou seletivo</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da prefeitura e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2017</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta por <strong>7 secretarias</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pelo <strong>Gabinete do Prefeito</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de <strong>2017</strong>.</p>\n<p>Sua elabora\u00e7\u00e3o contou com a <strong>participa\u00e7\u00e3o da sociedade civil</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de <strong>doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 100,00 a R$ 225,00</strong> e atende um total aproximado de <strong>30.000</strong> beneficiados.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui feiras agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei de de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a <strong>dire\u00e7\u00e3o da escola, a comunidade escolar e as secretarias de meio ambiente e educa\u00e7\u00e3o</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>18</strong> hortas comunit\u00e1rias.</p>\n<p>A prefeitura fornece apoio na forma de <strong>uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>193 mil</strong> refei\u00e7\u00f5es por dia.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras <strong>em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>30% a 50% do or\u00e7amento</strong> recebido pelo PNAE.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Osasco","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/osasco/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Osasco\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_osasco-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703276129:1","%_thumbnail_id%":"750","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Osasco","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"934\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Osasco</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Osasco</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">701.428 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">64.954 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 six-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_8\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_23  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2006.<br />\nLei Municipal n\u00ba 4.842, de 30 de outubro de 2017. Decreto Municipal n\u00ba 9.633, de 17 de agosto de 2006, Lei Municipal n\u00ba 4.002, de 16 de fevereiro de 2006, Lei Municipal n\u00ba 4.577, de 05 de julho de 2013, Lei Municipal n\u00ba 4.640, de 12 de junho de 2014, Decreto Municipal n\u00ba 11.106, de 14 de maio de 2015, Lei Municipal n\u00ba 4.886, de 29 de maio de 2018, Decreto Municipal n\u00ba 11.729, de 12 de julho de 2018, Lei Municipal n\u00ba 4.936, de 28 de dezembro de 2018. Lei Municipal n\u00ba 5.155, de 10 de dezembro de 2021. Lei Municipal n\u00ba 5.157, de 15 de dezembro de 2021</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_24  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde 2006, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da prefeitura e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_25  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02017.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_26  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta por 7 secretarias.<br />\nA presid\u00eancia \u00e9 exercida pelo Gabinete do Prefeito.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_28  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de 2017.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_29  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_30  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 100,00 a R$ 225,00 e atende um total aproximado de 30.000 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_31  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui feiras agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_32  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_33  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei de de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nO respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola, a comunidade escolar e as secretarias de meio ambiente e educa\u00e7\u00e3o.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 18 hortas comunit\u00e1rias.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 193 mil refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de 30% a 50% do or\u00e7amento recebido pelo PNAE.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:12:29","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-23.5326334","%_wpgmp_metabox_longitude%":"-46.7915243","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:17:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"15\";i:7;s:2:\"18\";i:8;s:2:\"20\";i:9;s:2:\"22\";i:10;s:2:\"23\";i:11;s:2:\"27\";i:12;s:2:\"28\";i:13;s:2:\"29\";i:14;s:2:\"33\";i:15;s:2:\"37\";i:16;s:2:\"38\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_e359428cf81bf5bf7c703a0feeea74f7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_f9c8cd183f9f0541f393d874d276e186":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_5a121ea035e7191ee458dbdf863dfcab":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3c086b84a60744d163cbedac9c66cb4e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_977b90a6fb8e7f37ae43cd20cd918cc9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_bbfb8c9c12477c7a24a408b03cea5518":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1ebe3b3be26177ce076c761c98c54925":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_145ab8b15bc361b85e161e2aa64a2d4b":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_466b366a0c7c1eefeadaba21a944f956":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4d1a336505729a06e3f973fafcea54ea":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f0fce30a74acf0475a1240d8b721cc0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Subtropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":934,"custom_filters":{"%regiao%":["Centro-Sul | Subtropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}}]},{"source":"post","title":"Maric\u00e1","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nMaric\u00e1 <span class=\"fc-badge info\"></span></div>\r\n Rio de Janeiro, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/marica/\">Ver mais</a></p></div>","content":"Rio de Janeiro, Brasil","location":{"lat":"-22.9160994","lng":"-42.819192","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/marica/","zoom":5,"extra_fields":{"post_excerpt":"Rio de Janeiro, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>167.668 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>361.572 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro Sul | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.marica.rj.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://ibge.gov.br/cidades-e-estados/rj/marica.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.3\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivo Fiscal\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.3\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.25.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pagamentos por Servi\u00e7os Ambientais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pagamentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"782\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivos fiscais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"601\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Incentivo Fiscal</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.25.0\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de<strong> desde 2022</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de <strong>processo eleitoral ou seletivo</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da prefeitura e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2022</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2021</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de <strong>Educa\u00e7\u00e3o, Sa\u00fade , Economia Solid\u00e1ria, Agricultura Pecu\u00e1ria e Pesca, Assist\u00eancia Social, Cidade Sustent\u00e1vel, Secretaria de Desenvolvimento Econ\u00f4mico, Ci\u00eancia e Tecnologia e Autarquia Municipal CODEMAR</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela secretaria de <strong>Economia Solid\u00e1ria</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>\n<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>Obesidade 42,6% e sobrepeso 32,90%</strong><br />Entre 13 e 17 anos: <strong>Obesidade 18,94% e sobrepeso 20,86%</strong><br />Entre 4 e 9 anos: <strong>Obesidade 25,14% e sobrepeso 18,30%</strong><br />Entre 2 e 4 anos: <strong>Obesidade 9,6% e sobrepeso 28,20%</strong><br />Abaixo de 2 anos: <strong>Obesidade 4% e sobrepeso 30,40%</strong></p>\n</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existe <strong>1</strong> restaurante popular custeados pela prefeitura, com capacidade para preparar e distribuir de <strong>1.200 refei\u00e7\u00f5es</strong> diariamente, com alimentos fornecidos pela <strong>agricultura familiar/local acompanhamento nutricional no seu preparo</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 200,00</strong> e atende um total aproximado de <strong>42.400</strong> beneficiados.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>1</strong> feiras agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>4</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerante\" module_id=\"itinerante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de <strong>alimentos agroecol\u00f3gicos/org\u00e2nicos</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o <strong>Festival Art&amp;Bier e o Espraiado de Portas Abertas</strong>.</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares. S\u00e3o <strong>720 pescadores</strong> e <strong>2</strong> comunidades tradicionais pesqueiras: Zacarias e Guaratiba.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.<br />Atualmente <strong>5</strong> escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da pr\u00f3pria escola e a comunidade escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>33</strong> hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de <strong>uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas e possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras <strong>em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de <strong>30% do or\u00e7amento</strong> recebido pelo PNAE e <strong>metade da compra direta vem da produ\u00e7\u00e3o local</strong>.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a <strong>distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pagamentos\" module_id=\"pagamentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pagamentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"795\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 <strong>doado a produtores locais ou a programas de hortas</strong> da prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivos\" module_id=\"incentivos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivos fiscais</h5>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui <strong>Rec\u00f3leo, Rio Ecopets, Res\u00edduos Eletr\u00f4nico, Projeto baldinho do Bem - res\u00edduos org\u00e2nicos por alimentos agroecol\u00f3gicos (em constru\u00e7\u00e3o) e Mumbuca Verde- Troca dos res\u00edduos por cr\u00e9ditos da moeda social Mumbuca</strong>, que s\u00e3o tipos de incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"707\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>INCENTIVO FISCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Maric\u00e1","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/marica/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Maric\u00e1\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_osasco-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275719:1","%_edit_last%":"1","%_thumbnail_id%":"750","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Maric\u00e1","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"12","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"919\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_21 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Maric\u00e1</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_22 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_41   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Maric\u00e1</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">167.668 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">361.572 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro Sul | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_68 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_69 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_42    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_23 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_29 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-uma-linha botao-filtros-cidades df-button dfc-incentivo et_pb_bg_layout_light\" href=\"\">Incentivo Fiscal</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_13_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_13 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_24 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_45 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_46 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_47 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_48 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_49 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_50 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_31 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_51 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_52 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_53 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_54 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_55 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_56 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_32 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_57 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_58 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_59 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_60 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_61 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_62 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_33 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_63 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-485\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pagamentos por Servi\u00e7os Ambientais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_64 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_65 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_66 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-479\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivos fiscais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Incentivo Fiscal</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_67 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_68 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_34 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_69 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_70  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_71  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_72  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_73  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_74  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_75  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de desde 2022, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da prefeitura e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_26 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_76  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02022.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_27 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_37\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_77  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02021.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_28 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_38\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_78  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de Educa\u00e7\u00e3o, Sa\u00fade , Economia Solid\u00e1ria, Agricultura Pecu\u00e1ria e Pesca, Assist\u00eancia Social, Cidade Sustent\u00e1vel, Secretaria de Desenvolvimento Econ\u00f4mico, Ci\u00eancia e Tecnologia e Autarquia Municipal CODEMAR.<br />\nA presid\u00eancia \u00e9 exercida pela secretaria de Economia Solid\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_39\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_79  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: Obesidade 42,6% e sobrepeso 32,90%Entre 13 e 17 anos: Obesidade 18,94% e sobrepeso 20,86%Entre 4 e 9 anos: Obesidade 25,14% e sobrepeso 18,30%Entre 2 e 4 anos: Obesidade 9,6% e sobrepeso 28,20%Abaixo de 2 anos: Obesidade 4% e sobrepeso 30,40%</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_80  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existe 1 restaurante popular custeados pela prefeitura, com capacidade para preparar e distribuir de 1.200 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_41\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_81  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 200,00 e atende um total aproximado de 42.400 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_32 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_42\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_82  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 1 feiras agroecol\u00f3gica e/ou org\u00e2nica funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_33 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_43\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_83  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 4 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerante\" class=\"et_pb_section et_pb_section_34 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_44\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_84  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_35 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_45\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_85  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o Festival Art&amp;Bier e o Espraiado de Portas Abertas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_46\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_86  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_87  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares. S\u00e3o 720 pescadores e 2 comunidades tradicionais pesqueiras: Zacarias e Guaratiba.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_88  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.Atualmente 5 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da pr\u00f3pria escola e a comunidade escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_89  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 33 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_50\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_90  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas e possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_41 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_91  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_42 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_52\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_92  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de 30% do or\u00e7amento recebido pelo PNAE e metade da compra direta vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pagamentos\" class=\"et_pb_section et_pb_section_43 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_93  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_126  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_44 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_54\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_94  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_95  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e o composto gerado \u00e9 doado a produtores locais ou a programas de hortas da prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivos\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_56\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_96  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Incentivos fiscais</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Rec\u00f3leo, Rio Ecopets, Res\u00edduos Eletr\u00f4nico, Projeto baldinho do Bem &#8211; res\u00edduos org\u00e2nicos por alimentos agroecol\u00f3gicos (em constru\u00e7\u00e3o) e Mumbuca Verde- Troca dos res\u00edduos por cr\u00e9ditos da moeda social Mumbuca, que s\u00e3o tipos de incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>INCENTIVO FISCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:12:29","%_et_builder_version%":"VB|Divi|4.25.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-22.9160994","%_wpgmp_metabox_longitude%":"-42.819192","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:25:{i:0;s:1:\"5\";i:1;s:1:\"6\";i:2;s:1:\"7\";i:3;s:1:\"8\";i:4;s:2:\"12\";i:5;s:2:\"16\";i:6;s:2:\"18\";i:7;s:2:\"19\";i:8;s:2:\"20\";i:9;s:2:\"21\";i:10;s:2:\"23\";i:11;s:2:\"25\";i:12;s:2:\"26\";i:13;s:2:\"28\";i:14;s:2:\"29\";i:15;s:2:\"31\";i:16;s:2:\"32\";i:17;s:2:\"37\";i:18;s:2:\"38\";i:19;s:2:\"40\";i:20;s:2:\"41\";i:21;s:2:\"44\";i:22;s:2:\"45\";i:23;s:2:\"46\";i:24;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":""},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":919,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]},{"source":"post","title":"Niter\u00f3i","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nNiter\u00f3i <span class=\"fc-badge info\"></span></div>\r\n Rio de Janeiro, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/niteroi/\">Ver mais</a></p></div>","content":"Rio de Janeiro, Brasil","location":{"lat":"-22.8858975","lng":"-43.1152211","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/niteroi/","zoom":5,"extra_fields":{"post_excerpt":"Rio de Janeiro, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>515.317 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>129 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro Sul | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://niteroi.rj.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://luppa.comidadoamanha.org/mapa-luppa/niteroi/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2013</strong>.<strong></strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2013</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2017</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2022</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN.</p>\n<p>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>obesidade (36,78%) e sobrepeso (32,62%)</strong>;<br />Entre 13 e 17 anos: <strong>obesidade (17,76%) e sobrepeso (21,68%);</strong><br />Entre 10 e 12 anos: <strong>obesidade (17,76%) e sobrepeso (21,68%);</strong><br />Entre 5 e 9 anos: <strong>obesidade (20,78%) e sobrepeso (15,77%);</strong><br />Entre 2 e 4 anos: <strong>obesidade (9,40%) e sobrepeso (8,63%);</strong><br />Abaixo de 2 anos: <strong>obesidade (4,91%) e sobrepeso (8,96%);</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando o controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de <strong>doa\u00e7\u00f5es de alimentos \u00e0 entidades cadastradas</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>01</strong> restaurante popular custeados pela prefeitura, com capacidade para preparar e distribuir um total de <strong>2.100 refei\u00e7\u00f5es</strong> diariamente, com acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 500,00</strong> em m\u00e9dia e atende um total aproximado de <strong>28.000</strong> beneficiados.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>2</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio n\u00e3o tem zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>12 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong> e em <strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>30% a 50% do or\u00e7amento</strong> recebido pelo PNAE e <strong>menos da metade </strong>vem da produ\u00e7\u00e3o local.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP-f\u00edsica).</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>uma vez por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Niter\u00f3i","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/niteroi/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Niter\u00f3i\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_niteroi-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703275877:1","%_thumbnail_id%":"749","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Niter\u00f3i","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"9","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"908\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_47 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_97  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Niter\u00f3i</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_48 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_98   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_16 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_2 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Niter\u00f3i</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_11 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_8\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_18 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">515.317 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_12 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_20 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">129 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_13 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_21\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_10\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_22 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro Sul | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_14 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_23 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_144 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_145 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_99    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_49 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_60 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_100  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_146  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_61 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_101  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_14_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_14 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_15_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_15 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_16_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_16 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_17_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_17 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_18_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_18 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_19_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_19 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_20_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_20 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_50 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_62 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_102 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_103 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_104 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_105 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_106 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_43 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_107 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_44 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_63 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_108 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_45 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_109 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_46 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_110 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_47 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_111 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_48 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_112 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_49 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_113 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_50 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_64 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_114 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_51 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_115 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_52 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_116 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_53 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_117 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_54 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_118 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_55 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_119 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_56 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_65 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_120 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_57 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_121  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_122  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_123  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_124  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_125  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_51 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_66\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_126  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2013.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_149  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_52 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_67\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_127  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_150  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_151  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2013, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_152  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_53 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_68\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_128  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_153  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_154  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02017.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_155  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_54 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_69\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_129  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_156  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_157  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02022.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_158  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_55 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_70\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_130  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_159  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_160  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_161  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_56 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_71\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_131  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_162  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_163  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_164  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_57 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_72\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_132  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_165  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_166  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: obesidade (36,78%) e sobrepeso (32,62%);Entre 13 e 17 anos: obesidade (17,76%) e sobrepeso (21,68%);Entre 10 e 12 anos: obesidade (17,76%) e sobrepeso (21,68%);Entre 5 e 9 anos: obesidade (20,78%) e sobrepeso (15,77%);Entre 2 e 4 anos: obesidade (9,40%) e sobrepeso (8,63%);Abaixo de 2 anos: obesidade (4,91%) e sobrepeso (8,96%);</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_167  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_58 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_73\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_133  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_168  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_169  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando o controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_170  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_59 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_74\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_134  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_171  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_172  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00f5es de alimentos \u00e0 entidades cadastradas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_173  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_60 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_75\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_135  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_174  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_175  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 01 restaurante popular custeados pela prefeitura, com capacidade para preparar e distribuir um total de 2.100 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_176  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_61 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_76\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_136  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_177  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_178  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 500,00 em m\u00e9dia e atende um total aproximado de 28.000 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_179  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_62 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_77\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_137  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_180  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_181  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 2 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_182  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_63 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_78\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_138  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_183  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_184  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_185  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_64 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_79\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_139  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_186  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_187  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio n\u00e3o tem zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_188  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_65 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_80\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_140  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_189  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_190  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 12 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_191  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_66 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_81\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_141  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_192  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_193  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_194  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_67 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_82\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_142  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_195  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_196  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de 30% a 50% do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP-f\u00edsica).<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_197  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_68 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_83\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_143  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_198  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_199  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_200  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_69 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_84\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_144  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_201  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_202  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada uma vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_203  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:12:30","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_yoast_wpseo_content_score%":"30","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-22.8858975","%_wpgmp_metabox_longitude%":"-43.1152211","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:19:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"12\";i:7;s:2:\"14\";i:8;s:2:\"15\";i:9;s:2:\"16\";i:10;s:2:\"18\";i:11;s:2:\"19\";i:12;s:2:\"20\";i:13;s:2:\"24\";i:14;s:2:\"28\";i:15;s:2:\"37\";i:16;s:2:\"38\";i:17;s:2:\"39\";i:18;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_643764ceb2242f399486d474466afb5c":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_d271948d37ef066fec439f85a7d40517":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8156e683614bff95cdef244f7b9d0c05":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_70a40745b44eeac1f59df327c2070e48":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8a19a379ad70facb592c17bbccebb64d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3c086b84a60744d163cbedac9c66cb4e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_cee412bcabe1b1d9f41c5e486abd4e85":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3d169557b8089f60f0bc76cf00869f7e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ee8e69706d13f04f76e0196fb5942e03":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1986162cb179633fb012dcb18b4c3d27":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1ebe3b3be26177ce076c761c98c54925":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_145ab8b15bc361b85e161e2aa64a2d4b":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_466b366a0c7c1eefeadaba21a944f956":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ff2fda3ad65195e7a48ebbd33f02e411":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_926915f01c59231473997dd9cfe8e7cf":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4a05a17bb0504c5cd1cacca1d674db05":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_220c4d5e8f37bc9b0c4035dedbbebb7a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":908,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Contagem","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nContagem <span class=\"fc-badge info\"></span></div>\r\n Minas Gerais, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/contagem/\">Ver mais</a></p></div>","content":"Minas Gerais, Brasil","location":{"lat":"-19.9161522","lng":"-44.0809035","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/contagem/","zoom":5,"extra_fields":{"post_excerpt":"Minas Gerais, Brasil","post_content":"<!-- wp:divi/placeholder -->\n[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>673.849 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>194 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro Sul | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://portal.contagem.mg.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/mg/contagem.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pesquisa de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pesquisa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"893\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Cozinha comunit\u00e1ria\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#cozinha\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"775\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mapeamento\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Central de beneficiamento de alimentos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#central\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"587\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pagamentos por Servi\u00e7os Ambientais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pagamentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"782\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2009</strong>.</p>\n<p><strong>Lei n\u00ba 4.276, de 15 de julho de 2009.</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2005</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2013</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Comit\u00ea Intersetorial de Seguran\u00e7a Alimentar Nutricional Sustent\u00e1vel - CISANS, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: <strong>Secretaria Municipal de Desenvolvimento Social; Secretaria Municipal de Sa\u00fade; Secretaria Municipal de Educa\u00e7\u00e3o; Secretaria Municipal de Defesa Social; Secretaria Municipal de Direitos Humanos e Cidadania; Secretaria Municipal Obras e Servi\u00e7os Urbanos; Secretaria Municipal de Desenvolvimento Urbano e Habita\u00e7\u00e3o; Secretaria Municipal de Governo; Secretaria Municipal de Administra\u00e7\u00e3o; Secretaria Municipal de Planejamento, Or\u00e7amento e Gest\u00e3o; Secretaria Municipal de Meio Ambiente e Desenvolvimento Sustent\u00e1vel; Secretaria Municipal de Trabalho e Gera\u00e7\u00e3o de Renda; Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional Sustent\u00e1vel; Conselho Municipal de Alimenta\u00e7\u00e3o Escolar.</strong></p>\n<p>A presid\u00eancia \u00e9 exercida pela <strong>Secretaria de Desenvolvimento Social e Seguran\u00e7a Alimentar</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de <strong>2019</strong>.</p>\n<p>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos: <strong>obesidade (32,97%) e sobrepeso (31,82%)</strong><br />Entre 13 e 17 anos: sem dados<br />Entre 10 e 12 anos: sem dados<br />Entre 4 e 9 anos: <strong>obesidade (12,37%)</strong><br />Entre 2 e 4 anos: sem dados<br />Abaixo de 2 anos: sem dados</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pesquisa\" module_id=\"pesquisa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pesquisa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"896\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pesquisa de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas, compra da agricultura familiar, arrecada\u00e7\u00e3o da rede de doadores e distribui\u00e7\u00e3o para as redes cadastradas; apoio log\u00edstico para a compra da agricultura familiar; colabora\u00e7\u00e3o para o Projeto Cesta Colorida, que s\u00e3o alimentos adquiridos da agricultura familiar e doados para fam\u00edlias em situa\u00e7\u00e3o de vulnerabilidade social acompanhadas pelo CRAS; apoio log\u00edstico a situa\u00e7\u00f5es emergenciais e Educa\u00e7\u00e3o Alimentar e Nutricional para as redes parceiras e usu\u00e1rios.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>05</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de <strong>4.700 refei\u00e7\u00f5es</strong> diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #cozinha\" module_id=\"cozinha\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"cozinha\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"786\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Cozinha comunit\u00e1ria</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>02</strong> cozinhas comunit\u00e1rias\u00a0 com capacidade para preparar e distribuir um total de <strong>700 refei\u00e7\u00f5es</strong> diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 100,00</strong> em m\u00e9dia e atende um total aproximado de <strong>2.300</strong> beneficiados.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>5</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>3</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>\n<p>Tamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o <strong>Festival de Ab\u00f3boras</strong> e a <strong>Feira da agricultura urbana e familiar</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares, que est\u00e1 em andamento.</p>\n<p>S\u00e3o 8 agricultores/as familiares e 53 agricultores/as urbanos, que produzem principalmente hortifruti, pecu\u00e1ria, apicultura, avicultura, piscicultura e agricultura urbana.</p>\n<p>Destes, 3 possuem DAP - Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>53 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico/org\u00e2nico</strong>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta s\u00e3o a dire\u00e7\u00e3o da escola e a secretaria de seguran\u00e7a de educa\u00e7\u00e3o.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>14 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas e possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #central\" module_id=\"central\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"central\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"686\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Central de Beneficiamento de Alimentos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Central de Beneficiamento de Alimentos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>11.300</strong> refei\u00e7\u00f5es por dia atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de <strong>30% do or\u00e7amento</strong> recebido pelo PNAE e <strong>menos da metade </strong>vem da produ\u00e7\u00e3o local.</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pagamentos\" module_id=\"pagamentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pagamentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"795\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este <strong>inclui emiss\u00f5es relacionadas aos sistemas alimentares</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>uma vez por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]\n<!-- /wp:divi/placeholder -->","post_title":"Contagem","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/contagem/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Contagem\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_contagem-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1708094833:1","%_edit_last%":"1","%_thumbnail_id%":"741","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Contagem","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"15","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"889\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_70 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_86\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_145  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_204  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_205  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Contagem</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_71 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_146   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_24 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_3 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Contagem</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_206  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_16 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_25\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_12\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_26 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_207  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">673.849 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_17 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_27\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_28 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_208  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">194 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_18 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_29\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_14\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_30 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_209  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro Sul | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_19 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_31 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_210  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_211 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_212 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_147    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_15\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_72 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_88 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_148  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_213  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_89 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_149  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_21_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_21 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_22_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_22 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_23_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_23 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_24_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_24 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_25_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_25 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_26_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_26 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_27_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_27 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_73 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_90 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_150 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_58 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_151 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_59 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_152 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_60 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_153 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_61 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_154 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_62 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_155 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_63 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_91 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_156 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_64 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_157 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_65 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png\" alt=\"Pesquisa de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_formulario-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-481\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pesquisa de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_158 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_66 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_159 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_67 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_160 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_68 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-490\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Cozinha comunit\u00e1ria</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_161 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_69 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_92 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_162 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_70 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_163 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_71 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_164 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_72 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_165 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_73 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_166 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_74 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_167 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_75 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_93 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_168 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_76 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_169 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_77 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_170 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_78 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_171 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_79 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_172 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_80 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-454\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Central de beneficiamento de alimentos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_173 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_81 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_94 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_174 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_82 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_175 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_83 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-485\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pagamentos por Servi\u00e7os Ambientais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_176 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_84 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_177 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_85 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_178 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_86 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_179 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_87 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_74 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_95\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_180  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_214  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_215  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2009.<br />\nLei n\u00ba 4.276, de 15 de julho de 2009.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_216  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_75 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_96\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_181  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_217  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_218  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2005, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_219  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_76 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_97\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_182  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_220  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_221  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02013.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_222  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_77 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_98\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_183  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_223  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_224  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_225  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_78 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_99\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_184  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_226  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_227  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Comit\u00ea Intersetorial de Seguran\u00e7a Alimentar Nutricional Sustent\u00e1vel &#8211; CISANS, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: Secretaria Municipal de Desenvolvimento Social; Secretaria Municipal de Sa\u00fade; Secretaria Municipal de Educa\u00e7\u00e3o; Secretaria Municipal de Defesa Social; Secretaria Municipal de Direitos Humanos e Cidadania; Secretaria Municipal Obras e Servi\u00e7os Urbanos; Secretaria Municipal de Desenvolvimento Urbano e Habita\u00e7\u00e3o; Secretaria Municipal de Governo; Secretaria Municipal de Administra\u00e7\u00e3o; Secretaria Municipal de Planejamento, Or\u00e7amento e Gest\u00e3o; Secretaria Municipal de Meio Ambiente e Desenvolvimento Sustent\u00e1vel; Secretaria Municipal de Trabalho e Gera\u00e7\u00e3o de Renda; Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional Sustent\u00e1vel; Conselho Municipal de Alimenta\u00e7\u00e3o Escolar.<br />\nA presid\u00eancia \u00e9 exercida pela Secretaria de Desenvolvimento Social e Seguran\u00e7a Alimentar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_228  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_79 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_100\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_185  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_229  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_230  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 do ano de 2019.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_231  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_80 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_101\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_186  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_232  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_233  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos: obesidade (32,97%) e sobrepeso (31,82%)Entre 13 e 17 anos: sem dadosEntre 10 e 12 anos: sem dadosEntre 4 e 9 anos: obesidade (12,37%)Entre 2 e 4 anos: sem dadosAbaixo de 2 anos: sem dados</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_234  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pesquisa\" class=\"et_pb_section et_pb_section_81 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_102\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_187  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_235  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pesquisa de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_236  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza controle de seguran\u00e7a alimentar atrav\u00e9s de cadastros e/ou formul\u00e1rios de usu\u00e1rios do CRAS.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_237  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_82 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_103\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_188  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_238  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_239  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas, compra da agricultura familiar, arrecada\u00e7\u00e3o da rede de doadores e distribui\u00e7\u00e3o para as redes cadastradas; apoio log\u00edstico para a compra da agricultura familiar; colabora\u00e7\u00e3o para o Projeto Cesta Colorida, que s\u00e3o alimentos adquiridos da agricultura familiar e doados para fam\u00edlias em situa\u00e7\u00e3o de vulnerabilidade social acompanhadas pelo CRAS; apoio log\u00edstico a situa\u00e7\u00f5es emergenciais e Educa\u00e7\u00e3o Alimentar e Nutricional para as redes parceiras e usu\u00e1rios.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_240  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_83 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_104\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_189  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_241  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_242  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 05 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de 4.700 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_243  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"cozinha\" class=\"et_pb_section et_pb_section_84 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_105\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_190  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_244  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Cozinha comunit\u00e1ria</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_245  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 02 cozinhas comunit\u00e1rias\u00a0 com capacidade para preparar e distribuir um total de 700 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_246  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_85 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_106\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_191  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_247  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_248  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 100,00 em m\u00e9dia e atende um total aproximado de 2.300 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_249  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_86 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_107\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_192  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_250  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_251  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 5 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_252  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_87 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_108\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_193  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_253  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_254  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 3 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_255  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_88 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_109\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_194  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_256  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_257  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_258  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_89 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_110\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_195  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_259  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_260  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o Festival de Ab\u00f3boras e a Feira da agricultura urbana e familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_261  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_90 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_111\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_196  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_262  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_263  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares, que est\u00e1 em andamento.<br />\nS\u00e3o 8 agricultores/as familiares e 53 agricultores/as urbanos, que produzem principalmente hortifruti, pecu\u00e1ria, apicultura, avicultura, piscicultura e agricultura urbana.<br />\nDestes, 3 possuem DAP &#8211; Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_264  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_91 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_112\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_197  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_265  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_266  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_267  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_92 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_113\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_198  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_268  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_269  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 53 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta s\u00e3o a dire\u00e7\u00e3o da escola e a secretaria de seguran\u00e7a de educa\u00e7\u00e3o.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_270  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_93 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_114\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_199  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_271  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_272  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 14 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_273  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_94 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_115\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_200  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_274  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_275  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_276  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_95 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_116\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_201  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_277  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_278  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas e possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_279  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"central\" class=\"et_pb_section et_pb_section_96 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_117\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_202  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_280  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Central de Beneficiamento de Alimentos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_281  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Central de Beneficiamento de Alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_282  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_97 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_118\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_203  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_283  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_284  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 11.300 refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_285  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_98 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_119\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_204  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_286  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_287  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE e menos da metade vem da produ\u00e7\u00e3o local.<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_288  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pagamentos\" class=\"et_pb_section et_pb_section_99 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_120\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_205  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_289  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_290  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_291  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_100 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_121\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_206  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_292  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_293  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_294  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_101 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_122\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_207  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_295  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_296  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_297  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_102 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_123\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_208  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_298  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_299  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_300  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_103 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_124\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_209  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_301  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_302  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada uma vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_303  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:12:30","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-19.9161522","%_wpgmp_metabox_longitude%":"-44.0809035","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:30:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"12\";i:7;s:2:\"14\";i:8;s:2:\"15\";i:9;s:2:\"16\";i:10;s:2:\"17\";i:11;s:2:\"18\";i:12;s:2:\"19\";i:13;s:2:\"20\";i:14;s:2:\"22\";i:15;s:2:\"23\";i:16;s:2:\"25\";i:17;s:2:\"27\";i:18;s:2:\"28\";i:19;s:2:\"29\";i:20;s:2:\"30\";i:21;s:2:\"31\";i:22;s:2:\"32\";i:23;s:2:\"33\";i:24;s:2:\"38\";i:25;s:2:\"41\";i:26;s:2:\"42\";i:27;s:2:\"44\";i:28;s:2:\"45\";i:29;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%_last_editor_used_jetpack%":"block-editor","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_0e06bb8ea2d6b8631b5b25901f6157de":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_d203d9c5ca98bfda694f2fa876e18e76":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_70a40745b44eeac1f59df327c2070e48":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8a19a379ad70facb592c17bbccebb64d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_6239435dff688575c4951096b663874c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3c086b84a60744d163cbedac9c66cb4e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_46de0ad5744aba0a28b04bf15a803c39":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_977b90a6fb8e7f37ae43cd20cd918cc9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_c8c8eacd5475c173d8bba4b7d74efa6d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_108ff824fd71c292d6571d452e37d745":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fb21a30ad4b920faa285dd563b873383":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_699e7e4a490cec8d44f209ef49562625":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8339c572ad7b20082abe93299f01b817":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_7352a25d42f823a4d80444302af4d227":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ee8e69706d13f04f76e0196fb5942e03":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1986162cb179633fb012dcb18b4c3d27":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1ebe3b3be26177ce076c761c98c54925":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_bb75751ba0773f535532ff7ac206dcc9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_479d0c80d1f91ddc5971aa1c600455d7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_145ab8b15bc361b85e161e2aa64a2d4b":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_466b366a0c7c1eefeadaba21a944f956":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f50cf8f4436757e67b743fa23268d1f1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_f3a67b0f6b8f65a14c8fa6be6a2e2384":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4d1a336505729a06e3f973fafcea54ea":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f0fce30a74acf0475a1240d8b721cc0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_5839bdfef6eb01c40fd7eb28c91f8b76":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c4226bc7119dad3a431f9e3e9a4068e7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a79153d7ae7b080aca4fb75beab390b3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b7fbe7594654b4e39f29781a316adc98":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_85075cedb384483a421dabc52d1d7de5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d27d133f0154902764c6ac450f7bc35e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f2673c7ff33c70c90d10e926397caefd":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d86b7944a72648aad2b02206e0c82c1a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a071358de769b683d941974803ce07d3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_33f7b40f7c3c3a952ce26076f37a9399":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_87d8efa144f14befeebea078da18e385":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_25c67584596ed420c429a8c7d7977279":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":889,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pesquisa de SAN","id":"14","type":"category","extension_fields":{"cat_order":"11"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Cozinha comunit\u00e1ria","id":"17","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa","id":"42","type":"category","extension_fields":{"cat_order":"39"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Salvador","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nSalvador <span class=\"fc-badge info\"></span></div>\r\n Bahia, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/salvador/\">Ver mais</a></p></div>","content":"Bahia, Brasil","location":{"lat":"-12.9777378","lng":"-38.5016363","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/salvador/","zoom":5,"extra_fields":{"post_excerpt":"Bahia, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>2.417.678 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>693.442 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"http://www.salvador.ba.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/ba/salvador.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivo Fiscal\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Frente Parlamentar de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#frente\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"558\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feira itinerante\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#itinerante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"868\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#refrigerantes\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"871\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#ultraprocessados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"872\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivos fiscais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"601\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Incentivo Fiscal</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de <strong>2004</strong>, com composi\u00e7\u00e3o de <strong>maioria da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de <strong>processo eleitoral ou seletivo</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da prefeitura e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2004</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #frente\" module_id=\"frente\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"frente\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"667\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Frente Parlamentar de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de <strong>doa\u00e7\u00e3o de alimentos a entidades cadastradas</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>2</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir de <strong>1.300 refei\u00e7\u00f5es</strong>\u00a0aos finais de semana, com <strong>acompanhamento nutricional</strong> no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>20</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>20</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #itinerante\" module_id=\"itinerante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"itinerante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"873\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras itinerantes</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de <strong>alimentos agroecol\u00f3gicos/org\u00e2nicos</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como <strong>Feiras em Pra\u00e7as da Cidade/Realizadas quinzenalmente</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.<br />Atualmente <strong>34</strong> escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.<br />O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a <strong>dire\u00e7\u00e3o da pr\u00f3pria escola</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>33</strong> hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>convencional</strong>.</p>\n<p>A prefeitura fornece apoio na forma de <strong>uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio fornece mudas agroecol\u00f3gicas/ org\u00e2nicas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>224 mil</strong> refei\u00e7\u00f5es por dia.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #refrigerantes\" module_id=\"refrigerantes\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"refrigerantes\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"874\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei/decreto que pro\u00edbe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #ultraprocessados\" module_id=\"ultraprocessados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"ultraprocessados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"875\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui lei/decreto que pro\u00edbe ou limita a venda da venda de ultraprocessados nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de <strong>30% a 50% </strong>do or\u00e7amento recebido pelo PNAE e <strong>mais de 50% vem da produ\u00e7\u00e3o local</strong>.</p>\n<p>No munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivos\" module_id=\"incentivos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivos fiscais</h5>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui o <strong>IPTU Verde</strong>, que \u00e9 um tipo de incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"707\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>INCENTIVO FISCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Salvador","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/salvador/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Salvador\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_osasco-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1708094891:1","%_thumbnail_id%":"750","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Salvador","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"11","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"856\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_104 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_126\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_210  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_304  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_305  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Salvador</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_105 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_211   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_32 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_4 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Salvador</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_306  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_21 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_33\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_16\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_34 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_307  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">2.417.678 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_22 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_35\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_17\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_36 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_308  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">693.442 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_23 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_37\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_18\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_38 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_309  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_24 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_39 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_310  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_311 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_312 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_212    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_19\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_106 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_128 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_213  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_313  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_129 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_214  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_28_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_28 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_29_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_29 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_30_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_30 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_31_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_31 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_32_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_32 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_33_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_33 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_34_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_34 botao-uma-linha botao-filtros-cidades df-button dfc-incentivo et_pb_bg_layout_light\" href=\"\">Incentivo Fiscal</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_35_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_35 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_107 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_130 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_215 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_88 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_216 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_89 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_217 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_90 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-456\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Frente Parlamentar de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_218 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_91 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_219 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_92 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_220 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_93 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_131 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_221 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_94 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_222 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_95 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png\" alt=\"Feira itinerante\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_trailer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-462\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feira itinerante</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_223 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_96 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_224 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_97 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_225 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_98 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_226 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_99 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_132 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_227 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_100 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_228 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_101 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_229 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_102 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_230 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_103 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_231 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_104 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png\" alt=\"Proibi\u00e7\u00e3o de refrigerante nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-refrigerante-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-460\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de refrigerante nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_232 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_105 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png\" alt=\"Proibi\u00e7\u00e3o de ultraprocessados nas escolas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_sinal-hamburguer-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-459\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_133 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_233 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_106 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_234 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_107 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_235 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_108 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_236 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_109 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_237 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_110 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_238 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_111 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_134 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_239 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_112 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-479\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivos fiscais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Incentivo Fiscal</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_240  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_241  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_242  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_243  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_244  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_108 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_135\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_245  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_314  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_315  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de 2004, com composi\u00e7\u00e3o de maioria da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da prefeitura e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_316  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_109 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_136\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_246  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_317  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_318  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02004.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_319  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"frente\" class=\"et_pb_section et_pb_section_110 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_137\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_247  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_320  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Frente Parlamentar de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_321  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_322  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_111 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_138\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_248  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_323  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_324  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_325  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_112 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_139\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_249  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_326  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_327  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 2 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir de 1.300 refei\u00e7\u00f5es\u00a0aos finais de semana, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_328  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_113 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_140\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_250  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_329  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_330  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 20 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_331  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_114 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_141\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_251  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_332  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_333  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 20 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_334  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"itinerante\" class=\"et_pb_section et_pb_section_115 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_142\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_252  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_335  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras itinerantes</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_336  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio funcionam feiras itinerantes com comercializa\u00e7\u00e3o de alimentos agroecol\u00f3gicos/org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_337  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_116 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_143\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_253  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_338  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_339  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_340  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_117 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_144\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_254  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_341  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_342  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como Feiras em Pra\u00e7as da Cidade/Realizadas quinzenalmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_343  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_118 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_145\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_255  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_344  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_345  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_346  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_119 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_146\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_256  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_347  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_348  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.Atualmente 34 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 convencional.O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da pr\u00f3pria escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_349  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_120 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_147\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_257  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_350  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_351  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 33 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 convencional.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_352  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_121 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_148\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_258  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_353  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_354  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_355  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_122 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_149\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_259  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_356  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_357  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/ org\u00e2nicas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_358  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_123 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_150\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_260  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_359  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_360  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 224 mil refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_361  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"refrigerantes\" class=\"et_pb_section et_pb_section_124 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_151\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_261  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_362  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de refrigerantes nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_363  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que pro\u00edbe a venda de refrigerantes e/ou bebidas a\u00e7ucaradas nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_364  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"ultraprocessados\" class=\"et_pb_section et_pb_section_125 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_152\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_262  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_365  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Proibi\u00e7\u00e3o de ultraprocessados nas escolas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_366  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui lei/decreto que pro\u00edbe ou limita a venda da venda de ultraprocessados nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_367  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_126 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_153\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_263  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_368  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_369  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_370  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_127 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_154\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_264  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_371  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_372  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa de 30% a 50% do or\u00e7amento recebido pelo PNAE e mais de 50% vem da produ\u00e7\u00e3o local.<br />\nNo munic\u00edpio existe central de log\u00edstica para apoiar a distribui\u00e7\u00e3o da produ\u00e7\u00e3o familiar nas escolas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_373  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_128 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_155\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_265  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_374  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_375  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_376  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_129 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_156\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_266  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_377  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_378  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_379  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_130 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_157\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_267  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_380  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_381  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_382  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivos\" class=\"et_pb_section et_pb_section_131 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_158\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_268  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_383  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Incentivos fiscais</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_384  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui o IPTU Verde, que \u00e9 um tipo de incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_385  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>INCENTIVO FISCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:12:31","%_et_builder_version%":"VB|Divi|4.24.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-12.9777378","%_wpgmp_metabox_longitude%":"-38.5016363","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:25:{i:0;s:1:\"5\";i:1;s:1:\"6\";i:2;s:1:\"9\";i:3;s:2:\"15\";i:4;s:2:\"16\";i:5;s:2:\"19\";i:6;s:2:\"20\";i:7;s:2:\"21\";i:8;s:2:\"22\";i:9;s:2:\"23\";i:10;s:2:\"27\";i:11;s:2:\"28\";i:12;s:2:\"29\";i:13;s:2:\"30\";i:14;s:2:\"31\";i:15;s:2:\"33\";i:16;s:2:\"34\";i:17;s:2:\"35\";i:18;s:2:\"37\";i:19;s:2:\"38\";i:20;s:2:\"40\";i:21;s:2:\"42\";i:22;s:2:\"44\";i:23;s:2:\"45\";i:24;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_last_editor_used_jetpack%":"block-editor","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_c0cea247b5b49099188c995f2d2d0df1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_346e040a7edf11f7b87ab1e0b03fec22":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_1ec3357063c735ea872d1dfc1ee8d982":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_23517a7084550c305a833d75c090cdab":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_019ebbc70bf13fb4c696915bd20bdcb8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9b189568903d9875d4284e6bae40b733":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_15d5a93135ffaaa2acbdca9ac945e548":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_977b90a6fb8e7f37ae43cd20cd918cc9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_c8c8eacd5475c173d8bba4b7d74efa6d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_108ff824fd71c292d6571d452e37d745":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_7fbbf35cc66a7551dba30bc18fe7e75b":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_bb7b93f4babbe8edc5c951cf21bdcbeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_b0f45d679478b431e5fe9203b59e5e81":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8339c572ad7b20082abe93299f01b817":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_7352a25d42f823a4d80444302af4d227":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_cc43e576b2891948f07b4a4e0202d3dc":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_c77d6d2f7e02ad7169f1688315680bea":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_64ed918eac00cafeba4c6dee51ac44a3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_056546f937824831dc0941827f0802cd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a79153d7ae7b080aca4fb75beab390b3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1ebe3b3be26177ce076c761c98c54925":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_25c515a8c7c838cc5bf115b564771e49":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_fbe921604b5bfc09e35aa98db93b9f80":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4d1a336505729a06e3f973fafcea54ea":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f0fce30a74acf0475a1240d8b721cc0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_5839bdfef6eb01c40fd7eb28c91f8b76":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c4226bc7119dad3a431f9e3e9a4068e7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_b7fbe7594654b4e39f29781a316adc98":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_e5b69360a4f76fa7c21682275585ad96":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ac0cf0f282102f2545db00069dcf5aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f21f98a7e69347ea6a73c341610097e4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_ee2cffcc9a467259555b63bcb2caf0e6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_6aef04c39a068301c7c87908c550b097":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d7688747de5ede0b104897d7e5ff431a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a071358de769b683d941974803ce07d3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_33f7b40f7c3c3a952ce26076f37a9399":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ca98dc181feae921d6150627f60c5942":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1738130b3f4648bc4707b79748b3435d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_104c37f6c71c02fff00a1c281f8e3d22":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Incentivo Fiscal, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":856,"custom_filters":{"%regiao%":["Nordeste | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Incentivo Fiscal","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Frente Parlamentar de SAN","id":"9","type":"category","extension_fields":{"cat_order":"6"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feira itinerante","id":"21","type":"category","extension_fields":{"cat_order":"18"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de refrigerantes nas escolas","id":"34","type":"category","extension_fields":{"cat_order":"31"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Proibi\u00e7\u00e3o de ultraprocessados nas escolas","id":"35","type":"category","extension_fields":{"cat_order":"32"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa","id":"42","type":"category","extension_fields":{"cat_order":"39"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]},{"source":"post","title":"Recife","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nRecife <span class=\"fc-badge info\"></span></div>\r\n Pernambuco, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/recife/\">Ver mais</a></p></div>","content":"Pernambuco, Brasil","location":{"lat":"-8.0578381","lng":"-34.8828969","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/recife/","zoom":5,"extra_fields":{"post_excerpt":"Pernambuco, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"]<p>1.488.920 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>218.843 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Nordeste | Tropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www2.recife.pe.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/pe/recife.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Cozinha comunit\u00e1ria\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#cozinha\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"775\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN desde <strong>2016</strong>.</p>\n<p><strong>LEI N\u00ba 18.213/2016</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2004</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de <strong>processo eleitoral ou seletivo</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2014</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de <strong>Meio Ambiente e Sustentabilidade, Secretaria de Pol\u00edtica Urbana e Licenciamento, Secretaria de Educa\u00e7\u00e3o, Secretaria da Mulher, Secretaria de Sa\u00fade, Secretaria de Saneamento e Secretaria de Desenvolvimento Social, Direitos Humanos, Juventude e Pol\u00edticas sobre Drogas</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela secretaria de <strong>Desenvolvimento Social, Direitos Humanos, Juventude e Pol\u00edticas sobre Drogas</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN, cuja elabora\u00e7\u00e3o contou com a <strong>participa\u00e7\u00e3o da sociedade civil</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>03</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de <strong>1.760 refei\u00e7\u00f5es</strong> diariamente, com <strong>acompanhamento nutricional no seu preparo</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #cozinha\" module_id=\"cozinha\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"cozinha\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"786\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Cozinha comunit\u00e1ria</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existe <strong>1</strong> cozinha comunit\u00e1ria custeada pela prefeitura, com capacidade para preparar e distribuir um total de <strong>200</strong> refei\u00e7\u00f5es diariamente.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>54</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>10</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal.</p>\n<p>Tamb\u00e9m existem centrais municipais e estaduais de abastecimento de alimentos, onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o <strong>Festival da Boa Comida (evento anual da Secretaria Executiva de Agricultura Urbana)</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>40 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico/org\u00e2nico</strong>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a <strong>dire\u00e7\u00e3o da escola e a comunidade escolar</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>4 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de <strong>doa\u00e7\u00e3o de insumos e treinamento</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas e possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>136.000</strong> refei\u00e7\u00f5es por dia.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de <strong>30% do or\u00e7amento</strong> recebido pelo PNAE.</p>\n<p>As chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP - f\u00edsica).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este <strong>inclui emiss\u00f5es relacionadas aos sistemas alimentares</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>uma vez</strong> por semana no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Recife","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/recife/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Recife\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_osasco-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1708094888:1","%_thumbnail_id%":"750","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Recife","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"11","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"846\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Recife</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Recife</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_populacao\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.488.920 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_quadro\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">218.843 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_pin\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Nordeste | Tropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=200%2C200&#038;ssl=1\" alt=\"Losan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=200%2C201&#038;ssl=1\" alt=\"Comsea\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=200%2C201&#038;ssl=1\" alt=\"Sisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=200%2C201&#038;ssl=1\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=200%2C201&#038;ssl=1\" alt=\"Caisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?resize=200%2C201&#038;ssl=1\" alt=\"Plano de SAN\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?resize=200%2C201&#038;ssl=1\" alt=\"Restaurante popular\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?resize=200%2C201&#038;ssl=1\" alt=\"Cozinha comunit\u00e1ria\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-490\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Cozinha comunit\u00e1ria</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras convencionais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=200%2C201&#038;ssl=1\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=200%2C201&#038;ssl=1\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas escolares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png?resize=200%2C200&#038;ssl=1\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=200%2C201&#038;ssl=1\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=200%2C201&#038;ssl=1\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=200%2C201&#038;ssl=1\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_8 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_23 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?resize=200%2C201&#038;ssl=1\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_24 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png?resize=200%2C201&#038;ssl=1\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_25 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=200%2C201&#038;ssl=1\" alt=\"Controle de desmatamento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_26 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=200%2C201&#038;ssl=1\" alt=\"Coleta seletiva\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_28  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_29  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN desde 2016.<br />\nLEI N\u00ba 18.213/2016</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_30  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2004, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_31  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02014.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_32  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_33  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas secretarias de Meio Ambiente e Sustentabilidade, Secretaria de Pol\u00edtica Urbana e Licenciamento, Secretaria de Educa\u00e7\u00e3o, Secretaria da Mulher, Secretaria de Sa\u00fade, Secretaria de Saneamento e Secretaria de Desenvolvimento Social, Direitos Humanos, Juventude e Pol\u00edticas sobre Drogas.<br />\nA presid\u00eancia \u00e9 exercida pela secretaria de Desenvolvimento Social, Direitos Humanos, Juventude e Pol\u00edticas sobre Drogas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 03 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de 1.760 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"cozinha\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Cozinha comunit\u00e1ria</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existe 1 cozinha comunit\u00e1ria custeada pela prefeitura, com capacidade para preparar e distribuir um total de 200 refei\u00e7\u00f5es diariamente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 54 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 10 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal.<br />\nTamb\u00e9m existem centrais municipais e estaduais de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente, como o Festival da Boa Comida (evento anual da Secretaria Executiva de Agricultura Urbana).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 40 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola e a comunidade escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_42  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 4 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/org\u00e2nicas e possui programa ou parceria para cria\u00e7\u00e3o de banco de sementes crioulas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 136.000 refei\u00e7\u00f5es por dia.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE.<br />\nAs chamadas p\u00fablicas admitem propostas por detentores individuais de Declara\u00e7\u00e3o de Aptid\u00e3o ao Programa Nacional de Fortalecimento da Agricultura Familiar (DAP &#8211; f\u00edsica).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada uma vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2024-08-18 22:51:59","%_et_builder_version%":"VB|Divi|4.24.1","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-8.0578381","%_wpgmp_metabox_longitude%":"-34.8828969","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:22:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"16\";i:7;s:2:\"17\";i:8;s:2:\"19\";i:9;s:2:\"20\";i:10;s:2:\"22\";i:11;s:2:\"23\";i:12;s:2:\"28\";i:13;s:2:\"29\";i:14;s:2:\"31\";i:15;s:2:\"33\";i:16;s:2:\"37\";i:17;s:2:\"38\";i:18;s:2:\"40\";i:19;s:2:\"43\";i:20;s:2:\"45\";i:21;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"60","%_last_editor_used_jetpack%":"block-editor","%um_content_restriction%":", 0, , 0, 0, , 0, ","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_c0cea247b5b49099188c995f2d2d0df1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_14243c36da4362f4a33f88b8130667cc":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_f73a8bdc043c92383d54b71e799417fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8156e683614bff95cdef244f7b9d0c05":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_6239435dff688575c4951096b663874c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_108ff824fd71c292d6571d452e37d745":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_b0f45d679478b431e5fe9203b59e5e81":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8339c572ad7b20082abe93299f01b817":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_bb75751ba0773f535532ff7ac206dcc9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_479d0c80d1f91ddc5971aa1c600455d7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a79153d7ae7b080aca4fb75beab390b3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b7fbe7594654b4e39f29781a316adc98":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_6aef04c39a068301c7c87908c550b097":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d7688747de5ede0b104897d7e5ff431a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a071358de769b683d941974803ce07d3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_33f7b40f7c3c3a952ce26076f37a9399":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Nordeste | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":846,"custom_filters":{"%regiao%":["Nordeste | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Cozinha comunit\u00e1ria","id":"17","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de agrobiodiversidade","id":"43","type":"category","extension_fields":{"cat_order":"40"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Belo Horizonte","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nBelo Horizonte <span class=\"fc-badge info\"></span></div>\r\n Minas Gerais, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/belo-horizonte/\">Ver mais</a></p></div>","content":"Minas Gerais, Brasil","location":{"lat":"-19.919052","lng":"-43.9386685","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/belo-horizonte/","zoom":5,"extra_fields":{"post_excerpt":"Minas Gerais, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>2.530.701 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>331.354 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>495 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://prefeitura.pbh.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/mg/belo-horizonte.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Central de beneficiamento de alimentos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#central\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"587\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Pagamentos por Servi\u00e7os Ambientais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pagamentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"782\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2012</strong>, com composi\u00e7\u00e3o de <strong>maioria da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de <strong>processo eleitoral ou seletivo</strong>.</p>\n<p>A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2017</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias: <strong>Subsecretaria de Assist\u00eancia Social Secretaria Municipal de Sa\u00fade; Secretaria Municipal de Educa\u00e7\u00e3o; Subsecretaria de Seguran\u00e7a Alimentar e Nutricional; Secretaria Municipal Adjunta de Direitos de Cidadania; Secretaria Municipal de Meio Ambiente; Superintend\u00eancia de Limpeza Urbana; Subsecretaria de Direitos Humanos e Cidadania; Secretaria Municipal de Desenvolvimento Econ\u00f4mico; Empresa Municipal de Turismo de Belo Horizonte</strong>.</p>\n<p>A presid\u00eancia \u00e9 exercida pela <strong>Subsecretaria de Seguran\u00e7a Alimentar e Nutricional</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 a de <strong>2017.</strong></p>\n<p>Sua elabora\u00e7\u00e3o contou com a <strong>participa\u00e7\u00e3o da sociedade civil</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de <strong>doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>04</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir refei\u00e7\u00f5es diariamente, com <strong>alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo</strong>.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>19</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>50</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Existem centrais municipais de abastecimento de alimentos, onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>151 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a <strong>dire\u00e7\u00e3o da escola</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>49 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de <strong>uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #central\" module_id=\"central\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"central\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"686\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Central de Beneficiamento de Alimentos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Central de Beneficiamento de Alimentos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de <strong>30% do or\u00e7amento</strong> recebido pelo PNAE.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pagamentos\" module_id=\"pagamentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pagamentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"795\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este <strong>inclui emiss\u00f5es relacionadas aos sistemas alimentares</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Belo Horizonte","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/belo-horizonte/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Belo Horizonte\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_belo-horizonte-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703273738:1","%_thumbnail_id%":"737","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Belo Horizonte","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"10","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"817\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_0 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_0  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_0  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_1  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Belo Horizonte</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_1 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_1   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Belo Horizonte</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_2  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">2.530.701 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">331.354 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">495 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_7 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_8 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_2    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_3  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_4 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_4  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_5 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_6 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-454\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Central de beneficiamento de alimentos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_8 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_23 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_24 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-485\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pagamentos por Servi\u00e7os Ambientais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_25 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_26  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_28  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_4 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_9\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_29  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_10  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_10\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_30  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2012, com composi\u00e7\u00e3o de maioria da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />\nA presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_11\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_31  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02017.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_32  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_33  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias: Subsecretaria de Assist\u00eancia Social Secretaria Municipal de Sa\u00fade; Secretaria Municipal de Educa\u00e7\u00e3o; Subsecretaria de Seguran\u00e7a Alimentar e Nutricional; Secretaria Municipal Adjunta de Direitos de Cidadania; Secretaria Municipal de Meio Ambiente; Superintend\u00eancia de Limpeza Urbana; Subsecretaria de Direitos Humanos e Cidadania; Secretaria Municipal de Desenvolvimento Econ\u00f4mico; Empresa Municipal de Turismo de Belo Horizonte.<br />\nA presid\u00eancia \u00e9 exercida pela Subsecretaria de Seguran\u00e7a Alimentar e Nutricional.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_34  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 a de 2017.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_35  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas e compra da agricultura familiar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 04 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 19 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 50 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem centrais municipais de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos periodicamente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 151 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_42  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 49 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"central\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Central de Beneficiamento de Alimentos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Central de Beneficiamento de Alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos de 30% do or\u00e7amento recebido pelo PNAE.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pagamentos\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:14:09","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_yoast_wpseo_content_score%":"60","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-19.919052","%_wpgmp_metabox_longitude%":"-43.9386685","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:21:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:2:\"10\";i:6;s:2:\"15\";i:7;s:2:\"16\";i:8;s:2:\"19\";i:9;s:2:\"20\";i:10;s:2:\"22\";i:11;s:2:\"23\";i:12;s:2:\"28\";i:13;s:2:\"29\";i:14;s:2:\"30\";i:15;s:2:\"32\";i:16;s:2:\"37\";i:17;s:2:\"38\";i:18;s:2:\"40\";i:19;s:2:\"41\";i:20;s:2:\"42\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_92da251beb9a7af1aa10e4dce3e633d8":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_4f29168da394a675fd4dda051cfa913d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8156e683614bff95cdef244f7b9d0c05":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_c8c8eacd5475c173d8bba4b7d74efa6d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fb21a30ad4b920faa285dd563b873383":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_b0f45d679478b431e5fe9203b59e5e81":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_699e7e4a490cec8d44f209ef49562625":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8339c572ad7b20082abe93299f01b817":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1ebe3b3be26177ce076c761c98c54925":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_5839bdfef6eb01c40fd7eb28c91f8b76":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c4226bc7119dad3a431f9e3e9a4068e7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_85075cedb384483a421dabc52d1d7de5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d27d133f0154902764c6ac450f7bc35e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_6aef04c39a068301c7c87908c550b097":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d7688747de5ede0b104897d7e5ff431a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f2673c7ff33c70c90d10e926397caefd":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d86b7944a72648aad2b02206e0c82c1a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a071358de769b683d941974803ce07d3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_33f7b40f7c3c3a952ce26076f37a9399":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Tropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":817,"custom_filters":{"%regiao%":["Centro-Sul | Tropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa","id":"42","type":"category","extension_fields":{"cat_order":"39"}}]},{"source":"post","title":"Curitiba","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nCuritiba <span class=\"fc-badge info\"></span></div>\r\n Paran\u00e1, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/curitiba/\">Ver mais</a></p></div>","content":"Paran\u00e1, Brasil","location":{"lat":"-25.4372382","lng":"-49.2699727","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/curitiba/","zoom":5,"extra_fields":{"post_excerpt":"Paran\u00e1, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" global_module=\"2752\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.963.726 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>435 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>Centro-Sul | Subtropical</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.curitiba.pr.gov.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/pr/curitiba.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"seven-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" hover_enabled=\"0\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\" sticky_enabled=\"0\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png\" alt=\"Caisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#caisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"773\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Frente Parlamentar de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#frente\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"558\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer dfc_nutricao\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de alimentos municipal\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png\" alt=\"Banco de alimentos municipal\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#alimentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"774\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Cozinha comunit\u00e1ria\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png\" alt=\"Cozinha comunit\u00e1ria\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#cozinha\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"775\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de transfer\u00eancia de renda\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png\" alt=\"Programa de transfer\u00eancia de renda\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#programa\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"803\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Eventos gastron\u00f4micos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png\" alt=\"Eventos gastron\u00f4micos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#eventos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"777\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.24.2\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas comunit\u00e1rias\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png\" alt=\"Programa de hortas comunit\u00e1rias\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comunitarias\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"778\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Volume alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#volume\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"780\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.24.2\" _module_preset=\"default\" hover_enabled=\"0\" global_colors_info=\"{}\" sticky_enabled=\"0\"][et_pb_blurb title=\"Pagamentos por Servi\u00e7os Ambientais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#pagamentos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"782\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restauracao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"783\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN, <strong>desde 2003</strong>.</p>\n<p><strong>LEI N\u00ba 10.698/2003, LEI N\u00ba 11.823/2006, LEI N\u00ba 14771/2015 - art 102 e 103, LEI N\u00ba 15.209/2018, LEI N\u00ba 15.461/2019 - art. 14, LEI N\u00ba 15.637/2020. Decretos: 1.010/2011, 289/2015, 1.361/2016, 598/2019, 1.706/2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado\u00a0<strong>desde o ano de 2003</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.</p>\n<p>Os representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.<br />A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2016</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #caisan\" module_id=\"caisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"caisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"784\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: <strong>Secretaria Municipal de Seguran\u00e7a Alimentar e Nutricional, Secretaria Municipal de Governo, Secretaria Municipal de Sa\u00fade, Secretaria Municipal de Educa\u00e7\u00e3o, Secretaria Municipal de Meio Ambiente, Secretaria Municipal de Comunica\u00e7\u00e3o Social, Secretaria Municipal de Esporte, Lazer e Juventude. Funda\u00e7\u00e3o de A\u00e7\u00e3o Social, Instituto de Pesquisa e Planejamento Urbano, Instituto Municipal de Administra\u00e7\u00e3o P\u00fablica, Funda\u00e7\u00e3o Cultural de Curitiba.</strong></p>\n<p>A presid\u00eancia \u00e9 exercida pela <strong>Secretaria Municipal de Seguran\u00e7a Alimentar e Nutricional - SMSAN</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #frente\" module_id=\"frente\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"frente\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"667\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Frente Parlamentar de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a0<strong>2021</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 a de <strong>2020-2023</strong>.</p>\n<p>Sua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 60 anos: <strong>sobrepeso (57,77%)</strong><br />Entre 20 e 59 anos: <strong>obesidade (38,36%) e sobrepeso (34,24%)</strong><br />Entre 10 e 19 anos: <strong>obesidade (18,94%) e sobrepeso (23,71%)</strong><br />Entre 5 e 9 anos: <strong>obesidade (19,38%) e sobrepeso (18,33%)</strong><br />Abaixo de 5 anos: <strong>peso elevado (3,7%)</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #alimentos\" module_id=\"alimentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"alimentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||2px|||\" global_module=\"785\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de alimentos municipal</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas, compra da agricultura familiar, capta\u00e7\u00e3o de alimentos por edital de patroc\u00ednio, campanhas de arrecada\u00e7\u00e3o e empresas parceiras, recebimento de doa\u00e7\u00f5es de alimentos sem valor comercial provenientes de feiras, armaz\u00e9m da fam\u00edlia e mercados municipais.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>05</strong> restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de <strong>4.700 refei\u00e7\u00f5es</strong> diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #cozinha\" module_id=\"cozinha\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"cozinha\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"786\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Cozinha comunit\u00e1ria</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem <strong>03</strong> cozinhas comunit\u00e1rias custeadas pela prefeitura, com capacidade para preparar e distribuir aproximadamente <strong>1.000 refei\u00e7\u00f5es</strong> diariamente, com acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #programa\" module_id=\"programa\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"programa\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"787\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de transfer\u00eancia de renda</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de <strong>R$ 70,00</strong> em m\u00e9dia e atende um total aproximado de <strong>12.211</strong> beneficiados.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>14</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.24.2\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>88</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>\n<p>Tamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados <strong>alimentos agroecol\u00f3gicos ou org\u00e2nicos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #eventos\" module_id=\"eventos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"eventos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"790\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Eventos gastron\u00f4micos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza eventos gastron\u00f4micos patrocinados ou fomentados pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.</p>\n<p>Atualmente <strong>48 escolas</strong> possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico/org\u00e2nico</strong>.</p>\n<p>Os respons\u00e1veis pela gest\u00e3o de cada horta s\u00e3o a dire\u00e7\u00e3o da escola, a comunidade escolar e a secretaria de seguran\u00e7a alimentar e nutricional.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comunitarias\" module_id=\"comunitarias\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comunitarias\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"793\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de hortas comunit\u00e1rias</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.</p>\n<p>Atualmente h\u00e1 <strong>45 hortas comunit\u00e1rias</strong> e o principal modelo de produ\u00e7\u00e3o \u00e9 <strong>agroecol\u00f3gico</strong>.</p>\n<p>A prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #volume\" module_id=\"volume\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"volume\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"794\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas <strong>315 mil refei\u00e7\u00f5es por dia</strong> atualmente.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em <strong>alimenta\u00e7\u00e3o saud\u00e1vel</strong> e em <strong>desperd\u00edcio e aproveitamento integral dos alimentos</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de <strong>50% do or\u00e7amento</strong> recebido pelo PNAE e <strong>metade </strong>vem da produ\u00e7\u00e3o local.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #pagamentos\" module_id=\"pagamentos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"pagamentos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"795\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este <strong>inclui emiss\u00f5es relacionadas aos sistemas alimentares</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restauracao\" module_id=\"restauracao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restauracao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"796\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e oferece a incentivo \u00e0 separa\u00e7\u00e3o de res\u00edduos atrav\u00e9s do Programa Cambio Verde, Programa Compostroca e Familia Folhas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>duas ou mais vezes por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Curitiba","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/curitiba/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Curitiba\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_curitiba-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703274601:1","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Curitiba","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"14","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"727\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"742","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_1 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_3\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_2  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_3  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_4  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Curitiba</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_2 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_3   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_0\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_0 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_0 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Curitiba</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_5  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_1 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_0\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_populacao\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_2 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_6  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.963.726 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_2 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_1\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_quadro\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_4 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_7  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">435 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_3 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_2\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=200%2C200&#038;ssl=1\" alt=\"\" title=\"icone_pin\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" data-recalc-dims=\"1\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_6 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_8  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Centro-Sul | Subtropical</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_4 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_7 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_9  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_10 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_11 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_4    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_3\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_3 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_5 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_5  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_12  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_6 seven-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_6  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_0_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_0 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_1_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_1 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_2_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_2 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_3_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_3 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_4_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_4 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_5_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_5 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_6_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_6 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_4 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_7 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_7 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_0 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=200%2C200&#038;ssl=1\" alt=\"Losan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_8 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_1 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=200%2C201&#038;ssl=1\" alt=\"Comsea\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_9 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_2 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=200%2C201&#038;ssl=1\" alt=\"Sisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_10 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_3 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=200%2C201&#038;ssl=1\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_11 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_4 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=200%2C201&#038;ssl=1\" alt=\"Caisan\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agenda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-464\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_12 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_5 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?resize=200%2C201&#038;ssl=1\" alt=\"Frente Parlamentar de SAN\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-456\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Frente Parlamentar de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_8 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_13 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_6 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?resize=200%2C201&#038;ssl=1\" alt=\"Plano de SAN\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_14 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_7 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=200%2C201&#038;ssl=1\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_15 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_8 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?resize=200%2C201&#038;ssl=1\" alt=\"Banco de alimentos municipal\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-fruta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-491\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de alimentos municipal</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_16 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_9 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?resize=200%2C201&#038;ssl=1\" alt=\"Restaurante popular\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_17 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_10 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?resize=200%2C201&#038;ssl=1\" alt=\"Cozinha comunit\u00e1ria\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_panela.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-490\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Cozinha comunit\u00e1ria</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_18 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_11 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de transfer\u00eancia de renda\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_moeda.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-488\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de transfer\u00eancia de renda</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_9 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_19 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_12 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_20 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_13 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=200%2C201&#038;ssl=1\" alt=\"Feiras convencionais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_21 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_14 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=200%2C201&#038;ssl=1\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_22 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_15 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=200%2C201&#038;ssl=1\" alt=\"Eventos gastron\u00f4micos\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cloche.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-474\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Eventos gastron\u00f4micos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_23 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_16 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?resize=200%2C201&#038;ssl=1\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_24 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_17 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas escolares\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_10 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_25 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_18 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de hortas comunit\u00e1rias\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_horta.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-483\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas comunit\u00e1rias</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_26 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_19 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=200%2C201&#038;ssl=1\" alt=\"Volume alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_bandeja.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-468\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Volume alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_27 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_20 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=200%2C201&#038;ssl=1\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_28 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=200%2C201&#038;ssl=1\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_29 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?resize=200%2C201&#038;ssl=1\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_30 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png?resize=200%2C201&#038;ssl=1\" alt=\"Pagamentos por Servi\u00e7os Ambientais\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_maos.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-485\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Pagamentos por Servi\u00e7os Ambientais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_11 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_31 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png?resize=200%2C201&#038;ssl=1\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_32 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?resize=200%2C201&#038;ssl=1\" alt=\"Restaura\u00e7\u00e3o de \u00e1reas degradadas\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-484\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaura\u00e7\u00e3o de \u00e1reas degradadas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_33 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=200%2C201&#038;ssl=1\" alt=\"Controle de desmatamento\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_34 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?resize=200%2C201&#038;ssl=1\" alt=\"Programa de compostagem\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_35 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=200%2C201&#038;ssl=1\" alt=\"Coleta seletiva\" srcset=\"https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?w=200&ssl=1 200w, https://i0.wp.com/luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png?resize=150%2C150&ssl=1 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" data-recalc-dims=\"1\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_5 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_12\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_37  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_13  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_14  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN, desde 2003.<br />\nLEI N\u00ba 10.698/2003, LEI N\u00ba 11.823/2006, LEI N\u00ba 14771/2015 &#8211; art 102 e 103, LEI N\u00ba 15.209/2018, LEI N\u00ba 15.461/2019 &#8211; art. 14, LEI N\u00ba 15.637/2020. Decretos: 1.010/2011, 289/2015, 1.361/2016, 598/2019, 1.706/2019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_15  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_6 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_13\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_38  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado\u00a0desde o ano de 2003, com composi\u00e7\u00e3o de 2/3 da sociedade civil.<br />\nOs representantes s\u00e3o escolhidos atrav\u00e9s de processo eleitoral ou seletivo.A presid\u00eancia \u00e9 ocupada por representante da sociedade civil e possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_7 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_14\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_39  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02016.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_8 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_15\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_40  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"caisan\" class=\"et_pb_section et_pb_section_9 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_16\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_41  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>CAISAN (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui CAISAN, que \u00e9 composta pelas seguintes secretarias e \u00f3rg\u00e3os: Secretaria Municipal de Seguran\u00e7a Alimentar e Nutricional, Secretaria Municipal de Governo, Secretaria Municipal de Sa\u00fade, Secretaria Municipal de Educa\u00e7\u00e3o, Secretaria Municipal de Meio Ambiente, Secretaria Municipal de Comunica\u00e7\u00e3o Social, Secretaria Municipal de Esporte, Lazer e Juventude. Funda\u00e7\u00e3o de A\u00e7\u00e3o Social, Instituto de Pesquisa e Planejamento Urbano, Instituto Municipal de Administra\u00e7\u00e3o P\u00fablica, Funda\u00e7\u00e3o Cultural de Curitiba.<br />\nA presid\u00eancia \u00e9 exercida pela Secretaria Municipal de Seguran\u00e7a Alimentar e Nutricional &#8211; SMSAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"frente\" class=\"et_pb_section et_pb_section_10 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_17\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_42  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Frente Parlamentar de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a02021.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_11 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_18\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_43  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio formulou plano municipal de SAN, cuja vers\u00e3o mais atual \u00e9 a de 2020-2023.<br />\nSua elabora\u00e7\u00e3o contou com a participa\u00e7\u00e3o da sociedade civil.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_12 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_19\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_44  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 60 anos: sobrepeso (57,77%)Entre 20 e 59 anos: obesidade (38,36%) e sobrepeso (34,24%)Entre 10 e 19 anos: obesidade (18,94%) e sobrepeso (23,71%)Entre 5 e 9 anos: obesidade (19,38%) e sobrepeso (18,33%)Abaixo de 5 anos: peso elevado (3,7%)</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"alimentos\" class=\"et_pb_section et_pb_section_13 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_20\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de alimentos municipal</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A prefeitura possui banco de alimentos, cujo modelo de funcionamento se d\u00e1 atrav\u00e9s de doa\u00e7\u00e3o de alimentos a entidades cadastradas, compra da agricultura familiar, capta\u00e7\u00e3o de alimentos por edital de patroc\u00ednio, campanhas de arrecada\u00e7\u00e3o e empresas parceiras, recebimento de doa\u00e7\u00f5es de alimentos sem valor comercial provenientes de feiras, armaz\u00e9m da fam\u00edlia e mercados municipais.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_14 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_21\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_46  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 05 restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir um total de 4.700 refei\u00e7\u00f5es diariamente, com alimentos fornecidos pela agricultura familiar/local e acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"cozinha\" class=\"et_pb_section et_pb_section_15 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_22\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_47  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Cozinha comunit\u00e1ria</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem 03 cozinhas comunit\u00e1rias custeadas pela prefeitura, com capacidade para preparar e distribuir aproximadamente 1.000 refei\u00e7\u00f5es diariamente, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"programa\" class=\"et_pb_section et_pb_section_16 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_23\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_48  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de transfer\u00eancia de renda</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio criou programa de transfer\u00eancia de renda no valor de R$ 70,00 em m\u00e9dia e atende um total aproximado de 12.211 beneficiados.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_17 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_24\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_49  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 14 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_18 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_25\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 88 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_19 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_26\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_51  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"eventos\" class=\"et_pb_section et_pb_section_20 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_27\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_52  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Eventos gastron\u00f4micos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza eventos gastron\u00f4micos patrocinados ou fomentados pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_21 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_28\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_53  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_22 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_29\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_64  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.<br />\nAtualmente 48 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />\nOs respons\u00e1veis pela gest\u00e3o de cada horta s\u00e3o a dire\u00e7\u00e3o da escola, a comunidade escolar e a secretaria de seguran\u00e7a alimentar e nutricional.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_66  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comunitarias\" class=\"et_pb_section et_pb_section_23 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_30\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_55  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_67  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de hortas comunit\u00e1rias</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_68  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Comunit\u00e1rias.<br />\nAtualmente h\u00e1 45 hortas comunit\u00e1rias e o principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico.<br />\nA prefeitura fornece apoio na forma de uso do espa\u00e7o p\u00fablico, doa\u00e7\u00e3o de insumos e treinamento.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_69  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"volume\" class=\"et_pb_section et_pb_section_24 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_56  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_70  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Volume alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_71  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Atrav\u00e9s do Programa de Alimenta\u00e7\u00e3o Escolar, s\u00e3o servidas 315 mil refei\u00e7\u00f5es por dia atualmente.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_72  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_25 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_32\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_57  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel e em desperd\u00edcio e aproveitamento integral dos alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_26 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_58  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa mais de 50% do or\u00e7amento recebido pelo PNAE e metade vem da produ\u00e7\u00e3o local.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_27 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_34\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_59  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_80  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_81  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"pagamentos\" class=\"et_pb_section et_pb_section_28 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_60  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Pagamentos por Servi\u00e7os Ambientais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa que incentiva pagamentos por servi\u00e7os ambientais.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_36\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_61  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa, e este inclui emiss\u00f5es relacionadas aos sistemas alimentares.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restauracao\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_37\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_62  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaura\u00e7\u00e3o de \u00e1reas degradadas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui iniciativa de restaura\u00e7\u00e3o de \u00e1reas degradas para uso agr\u00edcola (ainda que parcial).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_38\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_63  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_32 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_39\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_64  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico e oferece a incentivo \u00e0 separa\u00e7\u00e3o de res\u00edduos atrav\u00e9s do Programa Cambio Verde, Programa Compostroca e Familia Folhas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_33 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_65  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada duas ou mais vezes por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2024-08-15 08:42:31","%_et_builder_version%":"VB|Divi|4.24.2","%_et_pb_show_page_creation%":"off","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-25.4372382","%_wpgmp_metabox_longitude%":"-49.2699727","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:29:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"8\";i:5;s:1:\"9\";i:6;s:2:\"10\";i:7;s:2:\"12\";i:8;s:2:\"15\";i:9;s:2:\"16\";i:10;s:2:\"17\";i:11;s:2:\"18\";i:12;s:2:\"19\";i:13;s:2:\"20\";i:14;s:2:\"22\";i:15;s:2:\"23\";i:16;s:2:\"27\";i:17;s:2:\"28\";i:18;s:2:\"29\";i:19;s:2:\"33\";i:20;s:2:\"37\";i:21;s:2:\"38\";i:22;s:2:\"40\";i:23;s:2:\"41\";i:24;s:2:\"42\";i:25;s:2:\"44\";i:26;s:2:\"45\";i:27;s:2:\"46\";i:28;s:2:\"47\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_224900582d6ba7f0855179d1aba1dbfa":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_c3bfbaaca31563c49865ceef64667fe3":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_390cff658de275d1c7fc059a30c8d92c":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_9a0a15d65c2d638ee91a65e3e7151fbb":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_bc54a462feeeb94a69dec81505816fde":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_01f9182254a6aebfdca0636cd00faf3e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_4537de8554b4730828f96466a70463a5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_ac84d47c8407f729b010e032f11f17ab":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9b189568903d9875d4284e6bae40b733":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_a5d62d17e95e65b8f79663c1bc3c634e":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_bca74bf9a5c5bd48c49a3d6c32e26c5c":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_012a5040d0af8a3bcf40849ff8baaa12":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_054d1451da434acfd8d1a78e44497b9a":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_6239435dff688575c4951096b663874c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3c086b84a60744d163cbedac9c66cb4e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_6af3503b553e491421878d9d059c853a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_015a26245bcaddee4f247d59c9935b18":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_acce4e24add742dbbec7c4bdc245a6e4":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fcb9fd19fbea622065c0c674a95d3f3c":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6fa9c861a22455db329b99af54557589":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_977b90a6fb8e7f37ae43cd20cd918cc9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16bdde423e7ad563234e6a0031a63eeb":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_1f5bc70d7a17c4184321374ecf06a397":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ce69118098db76d5e828c170244c89d2":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_783800b43f0e4abf344e603dbbb3fcd6":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_b0f45d679478b431e5fe9203b59e5e81":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_576a993fdf922f4af9888e78be8094da":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_699e7e4a490cec8d44f209ef49562625":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_blurb_8339c572ad7b20082abe93299f01b817":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_7352a25d42f823a4d80444302af4d227":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_198913d5173b779bb427062f43ad8868":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_c3f15c1a955e29dd49fdcdb6af74fec0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_73722e8bd53bfa92e5fb809a036bd077":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_64ed918eac00cafeba4c6dee51ac44a3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_056546f937824831dc0941827f0802cd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f18ad865bee971c0834ef894302f51d4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_afb49c1da7a6ebbbfd5779488c0f39f3":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_bb75751ba0773f535532ff7ac206dcc9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_479d0c80d1f91ddc5971aa1c600455d7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_145ab8b15bc361b85e161e2aa64a2d4b":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_466b366a0c7c1eefeadaba21a944f956":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b4323ea9a276e75160ae253dded76af2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e4d72f89d496fe5ba488a9fb27d3ce":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_8ad54914d8331adf7f36e58f912ffcdb":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4d1a336505729a06e3f973fafcea54ea":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f0fce30a74acf0475a1240d8b721cc0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_31aac4e7eb7586fbb19dedf668f019f0":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a2f1b1898f921d4e1a24f32e71e6e18":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_910898f76067b30a4fa0e57935b5beca":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2f50ca0a02b541437c9654f82bc06b4d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_6aef04c39a068301c7c87908c550b097":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d7688747de5ede0b104897d7e5ff431a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_f2673c7ff33c70c90d10e926397caefd":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d86b7944a72648aad2b02206e0c82c1a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a071358de769b683d941974803ce07d3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_33f7b40f7c3c3a952ce26076f37a9399":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_87d8efa144f14befeebea078da18e385":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_25c67584596ed420c429a8c7d7977279":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_de70cb9a1e9d68457ac578512ff6a551":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_e0e54bdbcebb3a8f09e13e444cb88d9f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Subtropical","taxonomy=tema":""},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":727,"custom_filters":{"%regiao%":["Centro-Sul | Subtropical"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Caisan (C\u00e2mara Intersecretarias de Seguran\u00e7a Alimentar e Nutricional)","id":"8","type":"category","extension_fields":{"cat_order":"5"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Frente Parlamentar de SAN","id":"9","type":"category","extension_fields":{"cat_order":"6"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de alimentos municipal","id":"15","type":"category","extension_fields":{"cat_order":"12"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaurante popular","id":"16","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Cozinha comunit\u00e1ria","id":"17","type":"category","extension_fields":{"cat_order":"13"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de transfer\u00eancia de renda","id":"18","type":"category","extension_fields":{"cat_order":"14"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Eventos gastron\u00f4micos","id":"23","type":"category","extension_fields":{"cat_order":"20"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas comunit\u00e1rias","id":"29","type":"category","extension_fields":{"cat_order":"26"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Volume alimenta\u00e7\u00e3o escolar","id":"33","type":"category","extension_fields":{"cat_order":"30"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Pagamento por Servi\u00e7os Ambientais","id":"41","type":"category","extension_fields":{"cat_order":"38"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa","id":"42","type":"category","extension_fields":{"cat_order":"39"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Restaura\u00e7\u00e3o de \u00e1reas degradadas","id":"44","type":"category","extension_fields":{"cat_order":"41"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}}]},{"source":"post","title":"Porto Alegre","infowindow_content":"<div class=\"fc-main\">\r\n<div class=\"fc-item-title\">\r\nPorto Alegre <span class=\"fc-badge info\"></span></div>\r\n Rio Grande do Sul, Brasil\r\n<p><a target=\"_blank\" class=\"fc-btn fc-btn-small fc-btn-luppa\" href=\"https://luppa.comidadoamanha.org/mapa-luppa/porto-alegre/\">Ver mais</a></p></div>","content":"Rio Grande do Sul, Brasil","location":{"lat":"-30.0368176","lng":"-51.2089887","onclick_action":"marker","redirect_permalink":"https://luppa.comidadoamanha.org/mapa-luppa/porto-alegre/","zoom":5,"extra_fields":{"post_excerpt":"Rio Grande do Sul, Brasil","post_content":"[et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row custom_padding_last_edited=\"on|phone\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_color=\"#f8f7ec\" width=\"100%\" max_width=\"100%\" custom_margin=\"0px||||false|false\" custom_padding=\"2em|12em|2em|12em|true|true\" custom_padding_tablet=\"|4em||4em|false|true\" custom_padding_phone=\"|1.5em||1.5em|false|true\" saved_tabs=\"all\" global_colors_info=\"{}\" global_module=\"2752\" theme_builder_area=\"post_content\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"][et_pb_text _builder_version=\"4.24.0\" _module_preset=\"default\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px||true|false\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]<p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_font=\"|300|||||||\" text_text_color=\"#000000\" link_text_color=\"#000000\" custom_margin=\"0px||0px|0.5em|true|false\" custom_margin_tablet=\"0px||0px|0em|true|false\" custom_margin_phone=\"\" custom_margin_last_edited=\"on|phone\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" global_colors_info=\"{}\" theme_builder_area=\"post_content\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF90aXRsZSIsInNldHRpbmdzIjp7ImJlZm9yZSI6IiIsImFmdGVyIjoiIn19@[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" make_equal=\"on\" use_custom_gutter=\"on\" gutter_width=\"2\" specialty=\"on\" padding_top_2=\"0px\" padding_bottom_2=\"0px\" padding_top_bottom_link_2=\"true\" padding_left_right_link_2=\"false\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"\" width_last_edited=\"on|phone\" module_alignment=\"center\" inner_width=\"100%\" inner_max_width=\"1920px\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_column type=\"1_2\" specialty_columns=\"2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_row_inner custom_padding_last_edited=\"off|desktop\" _builder_version=\"4.23.1\" _module_preset=\"default\" background_enable_color=\"off\" width=\"78%\" width_tablet=\"78%\" width_phone=\"78%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|desktop\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" custom_padding_tablet=\"||||false|false\" custom_padding_phone=\"||||false|false\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_post_title meta=\"off\" featured_image=\"off\" _builder_version=\"4.23.1\" _module_preset=\"default\" title_font=\"|700|||||||\" title_font_size=\"27px\" title_line_height=\"0.1em\" meta_font=\"|700|||||||\" meta_text_color=\"#000000\" meta_font_size=\"18px\" meta_line_height=\"1.1em\" custom_margin=\"||1em||false|false\" custom_padding=\"||||false|false\" title_font_size_tablet=\"21px\" title_font_size_phone=\"20px\" title_font_size_last_edited=\"on|phone\" meta_font_size_tablet=\"16px\" meta_font_size_phone=\"14px\" meta_font_size_last_edited=\"on|phone\" global_colors_info=\"{}\"][/et_pb_post_title][et_pb_text _builder_version=\"4.23.1\" _dynamic_attributes=\"content\" _module_preset=\"default\" text_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" text_font_size=\"18px\" text_line_height=\"1em\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22text_text_color%22%93}\"]@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9leGNlcnB0Iiwic2V0dGluZ3MiOnsiYmVmb3JlIjoiIiwiYWZ0ZXIiOiIiLCJ3b3JkcyI6IiIsInJlYWRfbW9yZV9sYWJlbCI6IiJ9fQ==@[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" title_text=\"icone_populacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>1.492.530 habitantes</p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" title_text=\"icone_quadro\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>495 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner column_structure=\"1_2,1_2\" use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"90%\" width_tablet=\"100%\" width_phone=\"100%\" width_last_edited=\"on|tablet\" custom_margin=\"1.5em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_css_main_element=\"width: 10%!important;\" global_colors_info=\"{}\" custom_css_main_element_last_edited=\"on|desktop\" custom_css_main_element_tablet=\"width: 10%!important;\" custom_css_main_element_phone=\"width: 10%!important;\"][et_pb_image src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" title_text=\"icone_pin\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"3em\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column_inner][et_pb_column_inner type=\"1_2\" saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_padding=\"||||false|false\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_font_size=\"18px\" text_line_height=\"1em\" custom_margin=\"0.7em||||false|false\" global_colors_info=\"{}\"]<p>495 km<sup class=\"sobrescrito\">2</sup></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][et_pb_row_inner use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column_inner saved_specialty_column_type=\"1_2\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"0px||0px||true|false\" custom_padding=\"0px||||false|false\" global_colors_info=\"{}\"]<p>Para saber mais sobre a cidade, acesse:</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://prefeitura.poa.br/\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 site da prefeitura<br /></span></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|700|||||||\" text_orientation=\"center\" custom_margin=\"|||2em|false|false\" custom_margin_tablet=\"\" custom_margin_phone=\"|||0.7em|false|false\" custom_margin_last_edited=\"on|phone\" custom_padding=\"0.4em|1.5em|0.4em|1.5em|true|true\" link_option_url=\"https://www.ibge.gov.br/cidades-e-estados/rs/porto-alegre.html\" link_option_url_new_window=\"on\" custom_css_main_element=\"width: fit-content;||display: inline-block;\" border_width_all=\"2px\" border_color_all=\"#000000\" global_colors_info=\"{}\"]<p><span style=\"font-size: medium;\"><span class=\"et-pb-icon\" style=\"font-size: small;\">\ue02c</span>\u00a0 dados do ibge</span></p>[/et_pb_text][/et_pb_column_inner][/et_pb_row_inner][/et_pb_column][et_pb_column type=\"1_2\" _builder_version=\"4.16\" custom_padding=\"|||\" global_colors_info=\"{}\" custom_padding__hover=\"|||\"][et_pb_image src=\"@ET-DC@eyJkeW5hbWljIjp0cnVlLCJjb250ZW50IjoicG9zdF9mZWF0dXJlZF9pbWFnZSIsInNldHRpbmdzIjp7fX0=@\" align_tablet=\"center\" align_phone=\"\" align_last_edited=\"on|tablet\" _builder_version=\"4.23.1\" _dynamic_attributes=\"src\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_image][/et_pb_column][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"4em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|phone\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|tablet\" custom_margin=\"||0px||false|false\" custom_padding=\"0px||0px||true|false\" global_module=\"495\" saved_tabs=\"all\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" header_3_line_height=\"1.7em\" header_4_text_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22header_4_text_color%22%93}\"]<h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Selecione o tema</h4>[/et_pb_text][/et_pb_column][/et_pb_row][et_pb_row use_custom_gutter=\"on\" gutter_width=\"1\" module_class=\"eight-columns\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|tablet\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"0.2em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_button button_text=\"Governan\u00e7a e marcos legais\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Nutri\u00e7\u00e3o e Vulnerabilidades\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Abastecimento e Acesso a Alimentos\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Agricultura Local\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Alimenta\u00e7\u00e3o Escolar\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Resili\u00eancia Clim\u00e1tica e Circularidade\" button_alignment=\"left\" module_class=\"botao-filtros-cidades df-button dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Incentivo Fiscal\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][et_pb_button button_text=\"Todos\" button_alignment=\"left\" module_class=\"botao-uma-linha botao-filtros-cidades df-button\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_button=\"on\" button_use_icon=\"off\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22button_bg_color__hover%22%93}\" button_bg_color__hover_enabled=\"on|hover\" button_bg_color__hover=\"#8c2e72\" button_bg_enable_color__hover=\"on\"][/et_pb_button][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Section\" module_class=\"df-area\" _builder_version=\"4.23.1\" _module_preset=\"default\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" da_disable_devices=\"off|off|off\" global_colors_info=\"{}\" da_is_popup=\"off\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#losan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"504\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#comsea\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"510\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"gcid-68380820-40ed-4627-b408-a51f661248bc\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#sisan\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"515\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conferencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"519\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Frente Parlamentar de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#frente\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"558\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-governanca\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de SAN\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#plano\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"559\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Governan\u00e7a e Marcos Legais</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Dados de Obesidade e Sobrepeso\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#dados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"537\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-nutricao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Restaurante popular\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#restaurante\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"561\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras agroecologicas ou org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#agroecologicas\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"543\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Feiras convencionais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#convencionais\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"563\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-abastecimento\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mercados/ Central de Abastecimento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.24.0\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mercados\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"565\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Abastecimento e Acesso a Alimentos</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Zona rural no Plano Diretor\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#zona\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"567\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Conselho de desenvolvimento rural sustent\u00e1vel\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#conselho\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"571\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Mapeamento de produtores familiares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#mapeamento\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"573\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Lei de incentivo \u00e0 agricultura urbana\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#lei\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"575\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de hortas escolares\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#escolares\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"579\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivo\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"581\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Banco de sementes crioulas e mudas org\u00e2nicas\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#banco\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"583\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-agricultura\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Central de beneficiamento de alimentos\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#central\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"587\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Agricultura Local</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Capacita\u00e7\u00e3o de merendeiras\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#capacitacao\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"588\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.2\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compra\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"590\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-alimentacao\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#organicos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"592\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Alimenta\u00e7\u00e3o Escolar</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#resiliencia\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"593\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#inventario\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"595\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][/et_pb_row][et_pb_row column_structure=\"1_6,1_6,1_6,1_6,1_6,1_6\" use_custom_gutter=\"on\" gutter_width=\"2\" make_equal=\"on\" _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"78%\" width_tablet=\"93%\" width_phone=\"93%\" width_last_edited=\"on|desktop\" max_width=\"1920px\" max_width_tablet=\"93%\" max_width_phone=\"93%\" max_width_last_edited=\"on|phone\" module_alignment=\"center\" custom_margin=\"3em||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Controle de desmatamento\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#controle\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"597\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Programa de compostagem\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#compostagem\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"599\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-resiliencia\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Coleta seletiva\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#coleta\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"600\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" module_class=\"dfc-incentivo\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_blurb title=\"Incentivos fiscais\" image=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" module_class=\"tamanho-icone pointer\" _builder_version=\"4.23.1\" _module_preset=\"default\" header_text_align=\"center\" header_font_size=\"14px\" body_font=\"|700|||||||\" body_text_align=\"center\" body_text_color=\"#8c2e72\" body_line_height=\"1.1em\" custom_padding=\"2em|0.2em|2em|0.2em|true|true\" link_option_url=\"#incentivos\" border_radii=\"on|5%|5%|5%|5%\" global_module=\"601\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-68380820-40ed-4627-b408-a51f661248bc%22:%91%22body_text_color%22,%22body_text_color%22,%22body_text_color%22%93,%22gcid-77c91ae6-886e-4a0e-9bb0-096c4a48c42a%22:%91%22background_color__hover%22%93}\" background_color__hover=\"#ffd854\" background_enable_color__hover=\"on\"]<p>Incentivo Fiscal</p>\n[/et_pb_blurb][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][et_pb_column type=\"1_6\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #losan\" module_id=\"losan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"losan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"623\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui LOSAN\u00a0<strong>desde 2007.</strong><br /><strong>LEI COMPLEMENTAR N\u00ba 577, DE 16 DE OUTUBRO DE 2007</strong></p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #comsea\" module_id=\"comsea\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"comsea\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"658\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui COMSEA instalado desde o ano de<strong> desde 2007</strong>, com composi\u00e7\u00e3o de <strong>2/3 da sociedade civil</strong>.<br />A presid\u00eancia \u00e9 ocupada por representante da prefeitura e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #sisan\" module_id=\"sisan\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"sisan\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"662\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio aderiu ao SISAN em\u00a0<strong>2014</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conferencia\" module_id=\"conferencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conferencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"663\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a0<strong>2019</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #frente\" module_id=\"frente\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"frente\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"667\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Frente Parlamentar de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a0<strong>2021</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #plano\" module_id=\"plano\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"plano\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"670\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de SAN</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 construindo o 1\u00b0 plano municipal de SAN.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"gcid-03ea5474-56db-4f24-81aa-a16695232dc1\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"624\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #dados\" module_id=\"dados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"dados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"671\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Dados de Obesidade e Sobrepeso</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>\n<p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:</p>\n<p>Acima de 18 anos:\u00a0<strong>obesidade (46,60%) e sobrepeso (29,35%)\u00a0;</strong><br />Entre 13 e 17 anos:\u00a0<strong>obesidade (19,90%) e sobrepeso (22,45%);</strong><br />Entre 10 e 12 anos:\u00a0<strong>obesidade e sobrepeso (n\u00e3o informado);</strong><br />Entre 5 e 9 anos:\u00a0<strong>obesidade (17,30%) e sobrepeso (19,27%);</strong><br />Entre 2 e 4 anos:\u00a0<strong>obesidade (5,40%) e sobrepeso (8,50%);</strong><br />Abaixo de 2 anos:\u00a0<strong>obesidade e sobrepeso (n\u00e3o informado).</strong></p>\n</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #restaurante\" module_id=\"restaurante\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"restaurante\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"673\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Restaurante Popular</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>Existem\u00a0<strong>4</strong>\u00a0restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir de\u00a0<strong>400 a 700 refei\u00e7\u00f5es</strong>\u00a0aos finais de semana, com acompanhamento nutricional no seu preparo.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"672\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #agroecologicas\" module_id=\"agroecologicas\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"agroecologicas\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"678\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio possui <strong>8</strong> feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #convencionais\" module_id=\"convencionais\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"convencionais\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"682\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Feiras convencionais</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio existem <strong>42</strong> feiras convencionais funcionando.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mercados\" module_id=\"mercados\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mercados\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"683\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mercados/ Central de Abastecimento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n<div>Tamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"681\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #zona\" module_id=\"zona\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"zona\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"684\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Zona Rural no Plano Diretor</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<div>\n<div>O munic\u00edpio tem um percentual de <strong>8,28%</strong> do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n</div>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #conselho\" module_id=\"conselho\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"conselho\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"687\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #mapeamento\" module_id=\"mapeamento\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"mapeamento\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"688\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Mapeamento de Produtores Familiares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio tem mapeamento de produtores familiares feito no ano de <strong>2019</strong>, produzem principalmente folhosas, frut\u00edferas, hortali\u00e7as, pesca, pecu\u00e1ria e lavoura.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #lei\" module_id=\"lei\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"lei\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"689\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #escolares\" module_id=\"escolares\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"escolares\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"690\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de Hortas Escolares</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Programa de Hortas Escolares.<br />Atualmente <strong>15</strong> escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.<br />O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da pr\u00f3pria escola.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivo\" module_id=\"incentivo\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivo\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"691\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #banco\" module_id=\"banco\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"banco\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"692\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio fornece mudas agroecol\u00f3gicas/ org\u00e2nicas.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #central\" module_id=\"central\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"central\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"686\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Central de Beneficiamento de Alimentos</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui Central de Beneficiamento de Alimentos.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"685\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>AGRICULTURA LOCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #capacitacao\" module_id=\"capacitacao\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"capacitacao\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"832\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compra\" module_id=\"compra\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compra\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"697\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos que <strong>30% do or\u00e7amento</strong> recebido pelo PNAE e <strong>menos que a metade da compra direta vem da produ\u00e7\u00e3o local</strong>.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #organicos\" module_id=\"organicos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"organicos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"698\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa <strong>1,5%</strong> em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"696\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #resiliencia\" module_id=\"resiliencia\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"resiliencia\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"699\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #inventario\" module_id=\"inventario\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"inventario\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"703\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #controle\" module_id=\"controle\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"controle\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"704\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Controle de desmatamento</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #compostagem\" module_id=\"compostagem\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"compostagem\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"705\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Programa de compostagem</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #coleta\" module_id=\"coleta\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"coleta\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" global_module=\"706\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Coleta seletiva</h5>\n[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>A coleta seletiva \u00e9 realizada <strong>1 vez por semana</strong> no munic\u00edpio.</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"702\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section][et_pb_section fb_built=\"1\" admin_label=\"Popup - #incentivos\" module_id=\"incentivos\" module_class=\"popup\" _builder_version=\"4.23.1\" _module_preset=\"default\" max_width=\"50%\" max_width_tablet=\"75%\" max_width_phone=\"90%\" max_width_last_edited=\"on|tablet\" module_alignment=\"center\" custom_padding=\"1em||1em||true|false\" da_is_popup=\"on\" da_popup_slug=\"incentivos\" da_disable_devices=\"off|off|off\" border_radii=\"on|0.2em|0.2em|0.2em|0.2em\" box_shadow_style=\"preset3\" box_shadow_horizontal=\"1px\" global_colors_info=\"{}\" da_exit_intent=\"off\" da_has_close=\"on\" da_alt_close=\"off\" da_dark_close=\"off\" da_not_modal=\"on\" da_is_singular=\"off\" da_with_loader=\"off\" da_has_shadow=\"on\"][et_pb_row _builder_version=\"4.23.1\" _module_preset=\"default\" width=\"95%\" max_width=\"95%\" custom_margin=\"||||false|false\" custom_padding=\"0px||0px||true|false\" global_colors_info=\"{}\"][et_pb_column type=\"4_4\" _builder_version=\"4.23.1\" _module_preset=\"default\" global_colors_info=\"{}\"][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" saved_tabs=\"all\" global_colors_info=\"{}\"]<h5>Incentivos fiscais</h5>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_font=\"|300|||||||\" global_colors_info=\"{}\"]<p>O munic\u00edpio possui incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares, com a n\u00e3o incid\u00eancia de IPTU para produtores rurais em geral ( agroecol\u00f3gicos e convencionais).</p>[/et_pb_text][et_pb_text _builder_version=\"4.23.1\" _module_preset=\"default\" text_text_color=\"#FFFFFF\" background_color=\"#999999\" custom_padding=\"0.3em|1em|0.3em|1em|true|true\" custom_css_main_element=\"width: fit-content;\" border_radii=\"on|0.4em|0.4em|0.4em|0.4em\" global_module=\"707\" saved_tabs=\"all\" global_colors_info=\"{%22gcid-03ea5474-56db-4f24-81aa-a16695232dc1%22:%91%22background_color%22%93}\"]<p>INCENTIVO FISCAL</p>\n[/et_pb_text][/et_pb_column][/et_pb_row][/et_pb_section]","post_title":"Porto Alegre","post_link":"https://luppa.comidadoamanha.org/mapa-luppa/porto-alegre/","post_featured_image":"<div class=\"fc-feature-img\"><img loading=\"lazy\" decoding=\"async\" alt=\"Porto Alegre\" width=\"300\" height=\"168\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/pg_mapa-luppa_porto-alegre-300x168.png\" class=\"wp-post-image   wpgmp_featured_image\" ></div>","post_categories":"","post_tags":"","%_edit_lock%":"1703276541:1","%_et_pb_use_builder%":"on","%_et_gb_content_width%":"","%footnotes%":"","%_edit_last%":"1","%_et_pb_post_hide_nav%":"default","%_et_pb_page_layout%":"et_right_sidebar","%_et_pb_side_nav%":"off","%_yoast_wpseo_focuskw%":"Porto Alegre","%_yoast_wpseo_linkdex%":"60","%_yoast_wpseo_estimated-reading-time-minutes%":"12","%_yoast_wpseo_wordproof_timestamp%":"","%_et_pb_built_for_post_type%":"page","%_et_pb_ab_subjects%":"","%_et_pb_enable_shortcode_tracking%":"","%_et_pb_ab_current_shortcode%":"[et_pb_split_track id=\"379\" /]","%_et_pb_custom_css%":"","%_et_pb_gutter_width%":"3","%_thumbnail_id%":"447","%_global_colors_info%":"{}","%_et_pb_first_image%":"","%_et_pb_truncate_post%":"<p><div class=\"et_pb_section et_pb_section_25 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_31\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_50  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_73  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p><a href=\"/mapa-luppa\">Mapa LUPPA |</a> </p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_74  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Porto Alegre</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_26 et_pb_equal_columns et_section_specialty\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_2 et_pb_column_51   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row_inner et_pb_row_inner_5\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_8 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_post_title et_pb_post_title_1 et_pb_bg_layout_light  et_pb_text_align_left\"   >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_title_container\">\n\t\t\t\t\t<h1 class=\"entry-title\">Porto Alegre</h1>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_75  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_6 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_9\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_4\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png\" alt=\"\" title=\"icone_populacao\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_populacao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-448\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_10 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_76  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">1.492.530 habitantes</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_7 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_11\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_5\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png\" alt=\"\" title=\"icone_quadro\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_quadro-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-449\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_12 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_77  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">495 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_8 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_13\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_6\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png\" alt=\"\" title=\"icone_pin\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pin-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"wp-image-450\" /></span>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_14 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_78  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">495 km2</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row_inner et_pb_row_inner_9 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_15 et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_79  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Para saber mais sobre a cidade, acesse:</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_80 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 site da prefeitura</div>\n\t\t\t</div><div class=\"et_pb_with_border et_pb_module et_pb_text et_pb_text_81 et_clickable  et_pb_text_align_center et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">\ue02c\u00a0 dados do ibge</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_2 et_pb_column_52    et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_image et_pb_image_7\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<span class=\"et_pb_image_wrap \"></span>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_27 et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_33 et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_53  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_82  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h3>Panorama do sistema alimentar municipal</h3>\n<p>&nbsp;</p>\n<h4>Use os bot\u00f5es abaixo para selecionar um tema</h4></div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_34 eight-columns et_pb_gutters1\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_button_module_wrapper et_pb_button_7_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_7 botao-filtros-cidades df-button dfc-governanca et_pb_bg_layout_light\" href=\"\">Governan\u00e7a e marcos legais</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_8_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_8 botao-filtros-cidades df-button dfc-nutricao et_pb_bg_layout_light\" href=\"\">Nutri\u00e7\u00e3o e Vulnerabilidades</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_9_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_9 botao-filtros-cidades df-button dfc-abastecimento et_pb_bg_layout_light\" href=\"\">Abastecimento e Acesso a Alimentos</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_10_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_10 botao-uma-linha botao-filtros-cidades df-button dfc-agricultura et_pb_bg_layout_light\" href=\"\">Agricultura Local</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_11_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_11 botao-uma-linha botao-filtros-cidades df-button dfc-alimentacao et_pb_bg_layout_light\" href=\"\">Alimenta\u00e7\u00e3o Escolar</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_12_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_12 botao-filtros-cidades df-button dfc-resiliencia et_pb_bg_layout_light\" href=\"\">Resili\u00eancia Clim\u00e1tica e Circularidade</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_13_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_13 botao-uma-linha botao-filtros-cidades df-button dfc-incentivo et_pb_bg_layout_light\" href=\"\">Incentivo Fiscal</a>\n\t\t\t</div><div class=\"et_pb_button_module_wrapper et_pb_button_14_wrapper et_pb_button_alignment_left et_pb_module \">\n\t\t\t\t<a class=\"et_pb_button et_pb_button_14 botao-uma-linha botao-filtros-cidades df-button et_pb_bg_layout_light\" href=\"\">Todos</a>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_section et_pb_section_28 df-area et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_35 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_55 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_21 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png\" alt=\"Losan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-466\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_56 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_22 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png\" alt=\"Comsea\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_reuniao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-457\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_57 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_23 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png\" alt=\"Sisan\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_escudo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-478\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_58 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_24 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png\" alt=\"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_megafone-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-486\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_59 dfc-governanca  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_25 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png\" alt=\"Frente Parlamentar de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-publico-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-456\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Frente Parlamentar de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_60 dfc-governanca  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_26 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png\" alt=\"Plano de SAN\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_folha-maca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-480\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de SAN</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Governan\u00e7a e Marcos Legais</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_36 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_61 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_27 tamanho-icone pointer dfc_nutricao et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png\" alt=\"Dados de Obesidade e Sobrepeso\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_balanca-01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-467\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Dados de Obesidade e Sobrepeso</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_62 dfc-nutricao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_28 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png\" alt=\"Restaurante popular\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_talheres-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-461\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Restaurante popular</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Nutri\u00e7\u00e3o e Vulnerabilidades</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_63 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_29 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png\" alt=\"Feiras agroecologicas ou org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cesta-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-472\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras agroecologicas ou org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_64 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_30 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png\" alt=\"Feiras convencionais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_barraca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-469\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Feiras convencionais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_65 dfc-abastecimento  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_31 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png\" alt=\"Mercados/ Central de Abastecimento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_mercado-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-487\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mercados/ Central de Abastecimento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Abastecimento e Acesso a Alimentos</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_66 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_32 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png\" alt=\"Zona rural no Plano Diretor\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_campo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-471\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Zona rural no Plano Diretor</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_37 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_67 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_33 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png\" alt=\"Conselho de desenvolvimento rural sustent\u00e1vel\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_dialogo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-477\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Conselho de desenvolvimento rural sustent\u00e1vel</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_68 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_34 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png\" alt=\"Mapeamento de produtores familiares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_agricultor-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-465\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Mapeamento de produtores familiares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_69 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_35 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png\" alt=\"Lei de incentivo \u00e0 agricultura urbana\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_predio-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-455\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Lei de incentivo \u00e0 agricultura urbana</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_70 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_36 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png\" alt=\"Programa de hortas escolares\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_placa-milho-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-451\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de hortas escolares</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_71 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_37 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png\" alt=\"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_setas-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-458\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_72 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_38 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png\" alt=\"Banco de sementes crioulas e mudas org\u00e2nicas\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_muda-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-489\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Banco de sementes crioulas e mudas org\u00e2nicas</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_38 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_73 dfc-agricultura  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_39 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png\" alt=\"Central de beneficiamento de alimentos\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_pote-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-454\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Central de beneficiamento de alimentos</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Agricultura Local</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_74 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_40 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png\" alt=\"Capacita\u00e7\u00e3o de merendeiras\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_chef-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-473\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Capacita\u00e7\u00e3o de merendeiras</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_75 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_41 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png\" alt=\"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_cumbuca-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-476\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_76 dfc-alimentacao  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_42 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png\" alt=\"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_garfo-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-482\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Alimenta\u00e7\u00e3o Escolar</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_77 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_43 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png\" alt=\"Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_01-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-452\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_78 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_44 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png\" alt=\"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_planeta_02-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-453\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_row et_pb_row_39 et_pb_equal_columns et_pb_gutters2\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_1_6 et_pb_column_79 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_45 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png\" alt=\"Controle de desmatamento\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_tronco-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-463\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Controle de desmatamento</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_80 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_46 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png\" alt=\"Programa de compostagem\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_composteira-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-475\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Programa de compostagem</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_81 dfc-resiliencia  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_47 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"201\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png\" alt=\"Coleta seletiva\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_caminhao-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-470\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Coleta seletiva</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Resili\u00eancia Clim\u00e1tica e Circularidade</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_82 dfc-incentivo  et_pb_css_mix_blend_mode_passthrough\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_blurb et_pb_blurb_48 tamanho-icone pointer et_clickable et_pb_section_video_on_hover  et_pb_text_align_left  et_pb_blurb_position_top et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_blurb_content\">\n\t\t\t\t\t<div class=\"et_pb_main_blurb_image\"><span class=\"et_pb_image_wrap et_pb_only_image_mode_wrap\"><img loading=\"lazy\" decoding=\"async\" width=\"200\" height=\"200\" src=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png\" alt=\"Incentivos fiscais\" srcset=\"https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha.png 200w, https://luppa.comidadoamanha.org/wp-content/uploads/2023/12/icone_ficha-150x150.png 150w\" sizes=\"(max-width: 200px) 100vw, 200px\" class=\"et-waypoint et_pb_animation_top et_pb_animation_top_tablet et_pb_animation_top_phone wp-image-479\" /></span></div>\n\t\t\t\t\t<div class=\"et_pb_blurb_container\">\n\t\t\t\t\t\t<h4 class=\"et_pb_module_header\"><span>Incentivos fiscais</span></h4>\n\t\t\t\t\t\t<div class=\"et_pb_blurb_description\"><p>Incentivo Fiscal</p>\n</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_83  et_pb_css_mix_blend_mode_passthrough et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div class=\"et_pb_column et_pb_column_1_6 et_pb_column_84  et_pb_css_mix_blend_mode_passthrough et-last-child et_pb_column_empty\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"losan\" class=\"et_pb_section et_pb_section_29 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_40\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_85  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_83  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_84  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui LOSAN\u00a0desde 2007.LEI COMPLEMENTAR N\u00ba 577, DE 16 DE OUTUBRO DE 2007</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_85  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"comsea\" class=\"et_pb_section et_pb_section_30 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_41\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_86  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_86  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_87  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui COMSEA instalado desde o ano de desde 2007, com composi\u00e7\u00e3o de 2/3 da sociedade civil.A presid\u00eancia \u00e9 ocupada por representante da prefeitura e n\u00e3o possui secretaria executiva fornecida pela prefeitura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_88  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"sisan\" class=\"et_pb_section et_pb_section_31 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_42\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_87  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_89  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_90  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio aderiu ao SISAN em\u00a02014.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_91  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conferencia\" class=\"et_pb_section et_pb_section_32 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_43\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_88  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_92  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_93  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio realiza confer\u00eancia municipal de SAN, tendo realizado a \u00faltima em\u00a02019.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_94  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"frente\" class=\"et_pb_section et_pb_section_33 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_44\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_89  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_95  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Frente Parlamentar de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_96  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Frente Parlamentar de SAN, cuja instala\u00e7\u00e3o se deu no ano de\u00a02021.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_97  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"plano\" class=\"et_pb_section et_pb_section_34 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_45\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_90  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_98  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de SAN</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_99  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 construindo o 1\u00b0 plano municipal de SAN.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_100  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>GOVERNAN\u00c7A E MARCOS LEGAIS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"dados\" class=\"et_pb_section et_pb_section_35 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_46\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_91  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_101  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Dados de Obesidade e Sobrepeso</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_102  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>Os percentuais de obesidade e sobrepeso na popula\u00e7\u00e3o s\u00e3o:<br />\nAcima de 18 anos:\u00a0obesidade (46,60%) e sobrepeso (29,35%)\u00a0;Entre 13 e 17 anos:\u00a0obesidade (19,90%) e sobrepeso (22,45%);Entre 10 e 12 anos:\u00a0obesidade e sobrepeso (n\u00e3o informado);Entre 5 e 9 anos:\u00a0obesidade (17,30%) e sobrepeso (19,27%);Entre 2 e 4 anos:\u00a0obesidade (5,40%) e sobrepeso (8,50%);Abaixo de 2 anos:\u00a0obesidade e sobrepeso (n\u00e3o informado).</p></div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_103  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"restaurante\" class=\"et_pb_section et_pb_section_36 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_47\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_92  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_104  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Restaurante Popular</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_105  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Existem\u00a04\u00a0restaurantes populares custeados pela prefeitura, com capacidade para preparar e distribuir de\u00a0400 a 700 refei\u00e7\u00f5es\u00a0aos finais de semana, com acompanhamento nutricional no seu preparo.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_106  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>NUTRI\u00c7\u00c3O E VULNERABILIDADES</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"agroecologicas\" class=\"et_pb_section et_pb_section_37 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_48\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_93  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_107  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras agroecol\u00f3gicas ou org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_108  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui 8 feiras agroecol\u00f3gicas e/ou org\u00e2nicas funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_109  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"convencionais\" class=\"et_pb_section et_pb_section_38 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_49\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_94  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_110  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Feiras convencionais</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_111  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio existem 42 feiras convencionais funcionando.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_112  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mercados\" class=\"et_pb_section et_pb_section_39 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_50\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_95  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_113  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mercados/ Central de Abastecimento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_114  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">No munic\u00edpio, existe mercado municipal onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.<br />\nTamb\u00e9m existe central estadual de abastecimento de alimentos, onde s\u00e3o comercializados alimentos agroecol\u00f3gicos ou org\u00e2nicos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_115  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ABASTECIMENTO E ACESSO A ALIMENTOS</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"zona\" class=\"et_pb_section et_pb_section_40 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_51\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_96  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_116  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Zona Rural no Plano Diretor</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_117  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem um percentual de 8,28% do seu territ\u00f3rio de zona rural ou zona urbana destinada \u00e0 ocupa\u00e7\u00e3o agropecu\u00e1ria.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_118  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"conselho\" class=\"et_pb_section et_pb_section_41 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_52\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_97  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_119  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Conselho de Desenvolvimento Rural Sustent\u00e1vel</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_120  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui conselho de desenvolvimento rural e sustent\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_121  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"mapeamento\" class=\"et_pb_section et_pb_section_42 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_53\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_98  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_122  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Mapeamento de Produtores Familiares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_123  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio tem mapeamento de produtores familiares feito no ano de 2019, produzem principalmente folhosas, frut\u00edferas, hortali\u00e7as, pesca, pecu\u00e1ria e lavoura.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_124  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"lei\" class=\"et_pb_section et_pb_section_43 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_54\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_99  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_125  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Lei de Incentivo \u00e0 Agricultura Urbana</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_126  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio est\u00e1 implementando lei de incentivo \u00e0 agricultura urbana e periurbana.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_127  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"escolares\" class=\"et_pb_section et_pb_section_44 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_55\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_100  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_128  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de Hortas Escolares</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_129  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Programa de Hortas Escolares.Atualmente 15 escolas possuem hortas, cujo principal modelo de produ\u00e7\u00e3o \u00e9 agroecol\u00f3gico/org\u00e2nico.O respons\u00e1vel pela gest\u00e3o de cada horta \u00e9 a dire\u00e7\u00e3o da pr\u00f3pria escola.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_130  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivo\" class=\"et_pb_section et_pb_section_45 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_56\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_101  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_131  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_132  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_133  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"banco\" class=\"et_pb_section et_pb_section_46 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_57\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_102  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_134  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Banco de sementes crioulas e mudas org\u00e2nicas</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_135  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio fornece mudas agroecol\u00f3gicas/ org\u00e2nicas.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_136  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"central\" class=\"et_pb_section et_pb_section_47 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_58\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_103  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_137  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Central de Beneficiamento de Alimentos</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_138  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui Central de Beneficiamento de Alimentos.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_139  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>AGRICULTURA LOCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"capacitacao\" class=\"et_pb_section et_pb_section_48 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_59\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_104  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_140  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Capacita\u00e7\u00e3o de merendeiras</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_141  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de capacita\u00e7\u00e3o de merendeiras em alimenta\u00e7\u00e3o saud\u00e1vel.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_142  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compra\" class=\"et_pb_section et_pb_section_49 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_60\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_105  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_143  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_144  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A compra direta de alimentos da produ\u00e7\u00e3o familiar e/ou de comunidades tradicionais representa menos que 30% do or\u00e7amento recebido pelo PNAE e menos que a metade da compra direta vem da produ\u00e7\u00e3o local.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_145  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"organicos\" class=\"et_pb_section et_pb_section_50 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_61\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_106  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_146  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_147  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui regulamenta\u00e7\u00e3o para a compra de produtos org\u00e2nicos ou agroecol\u00f3gicos e esta representa 1,5% em rela\u00e7\u00e3o ao total de aquisi\u00e7\u00f5es para a alimenta\u00e7\u00e3o escolar.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_148  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>ALIMENTA\u00c7\u00c3O ESCOLAR</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"resiliencia\" class=\"et_pb_section et_pb_section_51 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_62\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_107  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_149  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Plano de resili\u00eancia - ou de a\u00e7\u00e3o - clim\u00e1tica</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_150  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui plano de resili\u00eancia &#8211; ou de a\u00e7\u00e3o &#8211; clim\u00e1tica.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_151  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"inventario\" class=\"et_pb_section et_pb_section_52 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_63\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_108  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_152  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_153  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui invent\u00e1rio de emiss\u00f5es de gases de efeito estufa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_154  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"controle\" class=\"et_pb_section et_pb_section_53 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_64\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_109  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_155  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Controle de desmatamento</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_156  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui a\u00e7\u00e3o para controle e fiscaliza\u00e7\u00e3o de desmatamento de vegeta\u00e7\u00e3o nativa.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_157  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"compostagem\" class=\"et_pb_section et_pb_section_54 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_65\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_110  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_158  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Programa de compostagem</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_159  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui programa de compostagem relacionada \u00e0 coleta de res\u00edduo org\u00e2nico.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_160  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"coleta\" class=\"et_pb_section et_pb_section_55 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_66\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_111  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_161  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><h5>Coleta seletiva</h5>\n</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_162  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">A coleta seletiva \u00e9 realizada 1 vez por semana no munic\u00edpio.</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_163  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>RESILI\u00caNCIA CLIM\u00c1TICA E CIRCULARIDADE</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div><div id=\"incentivos\" class=\"et_pb_section et_pb_section_56 popup et_section_regular\" >\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_row et_pb_row_67\">\n\t\t\t\t<div class=\"et_pb_column et_pb_column_4_4 et_pb_column_112  et_pb_css_mix_blend_mode_passthrough et-last-child\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_module et_pb_text et_pb_text_164  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">Incentivos fiscais</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_165  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\">O munic\u00edpio possui incentivo fiscal relacionado a tem\u00e1ticas dos sistemas alimentares, com a n\u00e3o incid\u00eancia de IPTU para produtores rurais em geral ( agroecol\u00f3gicos e convencionais).</div>\n\t\t\t</div><div class=\"et_pb_module et_pb_text et_pb_text_166  et_pb_text_align_left et_pb_bg_layout_light\">\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t<div class=\"et_pb_text_inner\"><p>INCENTIVO FISCAL</p>\n</div>\n\t\t\t</div>\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div>\n\t\t\t\t\n\t\t\t\t\n\t\t\t</div></p>\n","%_et_pb_truncate_post_date%":"2025-02-07 01:14:10","%_et_builder_version%":"VB|Divi|4.24.0","%_et_pb_show_page_creation%":"off","%_wp_page_template%":"default","%_et_builder_dynamic_assets_loading_attr_threshold%":"6","%_wpgmp_location_address%":"","%_wpgmp_location_city%":"","%_wpgmp_location_state%":"","%_wpgmp_location_country%":"","%_wpgmp_metabox_latitude%":"-30.0368176","%_wpgmp_metabox_longitude%":"-51.2089887","%_wpgmp_metabox_location_redirect%":"marker","%_wpgmp_metabox_custom_link%":"","%_wpgmp_map_id%":"a:1:{i:0;s:1:\"1\";}","%_wpgmp_metabox_marker_id%":"a:27:{i:0;s:1:\"4\";i:1;s:1:\"5\";i:2;s:1:\"6\";i:3;s:1:\"7\";i:4;s:1:\"9\";i:5;s:2:\"10\";i:6;s:2:\"12\";i:7;s:2:\"19\";i:8;s:2:\"20\";i:9;s:2:\"22\";i:10;s:2:\"24\";i:11;s:2:\"25\";i:12;s:2:\"26\";i:13;s:2:\"27\";i:14;s:2:\"28\";i:15;s:2:\"30\";i:16;s:2:\"31\";i:17;s:2:\"32\";i:18;s:2:\"37\";i:19;s:2:\"38\";i:20;s:2:\"39\";i:21;s:2:\"40\";i:22;s:2:\"42\";i:23;s:2:\"45\";i:24;s:2:\"46\";i:25;s:2:\"47\";i:26;s:2:\"48\";}","%_wpgmp_metabox_taxomomies_terms%":"","%_wpgmp_extensions_fields%":"","%_yoast_wpseo_content_score%":"30","%_et_dynamic_cached_shortcodes%":"et_pb_column_inner, et_pb_section, et_pb_row, et_pb_column, et_pb_row_inner, et_pb_blurb, et_pb_button, et_pb_fullwidth_menu, et_pb_image, et_pb_post_title, et_pb_text","%_et_dynamic_cached_attributes%":{"fullwidth":["on"],"use_custom_gutter":["on"],"gutter_width":["2","1","4"],"specialty":["on"],"background__hover_enabled":"on|hover"},"%et_enqueued_post_fonts%":{"family":{"et-gf-roboto":"Roboto:100,100italic,300,300italic,regular,italic,500,500italic,700,700italic,900,900italic"},"subset":["latin","latin-ext"],"cache_key":"{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"enable_all_character_sets\":\"false\"}"},"%_et_builder_module_features_cache%":["{\"gph\":0,\"divi\":\"4.27.4\",\"wp\":\"6.7.2\",\"tb\":{\"22\":\"2024-02-09 23:48:32\",\"18\":\"2024-03-11 21:17:11\"},\"wpe\":[]}",{"et_pb_section_3bd8d83084b2fc6ce2f9714a57658695":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_fullwidth_menu_cfa1986244a6100b6feeb36884c02717":{"glde":{"background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_4ed8e28611fb3b0a70bccf85ef9f4c91":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_65170a2f986b98c3eddb39029ba4a89a":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_d9195586fa5950fb67dd6b8e4f950089":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_09481a90c6251363027f570f2dbed670":{"bosh":true,"pos":true,"anim":true},"et_pb_text_fc98a0cf434e4ff562be77ea59aa8c08":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_3af12bf961487bf2d863108828c6d8f5":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e2ea12a1ae6c048d2a861ad6e3fb627":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_a6660090d595172f21e6d46d3c3ccbc5":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_inner_19a4814b2f9cf3cfd0b01fd969bd6303":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_85b0fec14008853f3088d50aab6254d3":{"bosh":true,"pos":true,"anim":true},"et_pb_post_title_500dc7c892f04da71866054adf15696e":{"glde":{"title_font_size":"26px","title_letter_spacing":"0px","title_line_height":"1em","meta_font_size":"14","meta_letter_spacing":"0px","meta_line_height":"1em","parallax":"off","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_698e36c7843154b27b04f054f8e646c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_06a390d9d2492b33b8376424f26de3c5":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_inner_80ed57e4231aa3382c42632ea340cfcf":{"bosh":true,"pos":true,"anim":true},"et_pb_image_f3ec9ca6ee6ba62af64924d123593aea":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_column_inner_8302675d5499d844ac7d11d2c42bc6b7":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_51c268a9acae6e1c2f8a49a4cc90d04d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_934fe85bce512000c56dc810e1c2dd23":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_image_f09167a05c15bf7e4ce1becbfd603cfb":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_inner_2740bd118efbb31dd55eef0828a747f9":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c8db406163827306e0295ec134864523":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_6bdc215e305d5e8383449d8bdddb7e12":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_62ed6793f7464462a8f0a68fa56a1fcd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_ced0257a7ca04bf6e6c563f75c758419":{"cuma":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_image_a86ce20e0258d703d395f64fbd0de683":{"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_adc320c1ded33518b15b1c5841969c48":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_63e80390f72b824a22d292dff0249666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ad00c4d4dd3c7952118fa6b7b672a0b1":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3ba0d69cd386efac2896867fb9d96981":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_row_23517a7084550c305a833d75c090cdab":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_button_115194a377636fe2902667ea6e8205c6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_789dddef35f88a0d8c0578e4997fa2f6":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_93709134161035b8e30aa8a64bf6e428":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_17f1ff8ef70d295bc1dbabec0b1357d5":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_23cab14d959a8a78c06f323053250fc1":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_ce08b88429da37ad529ab128f2180f92":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_019ebbc70bf13fb4c696915bd20bdcb8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_button_f0ed7c6f8ff6d148c7c2cd956398b1b8":{"tesh":true,"but":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9cb383a3c07db9b9145f5f8ef0b998de":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_ec528b90b7d006a378cedc59ad684e2c":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_dfc063b79f95af8935796f4bc6badcb1":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_6217e269cf953ee7dca48908df663fe0":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_20ac69c4a2a6652eb20161bdbaf751d5":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_dbabe3e9f86fdba57a53279e2883e618":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8156e683614bff95cdef244f7b9d0c05":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9b189568903d9875d4284e6bae40b733":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_a4f656258ee3e51ebde3e6722cd3c7da":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_cd644615ae2884eb04df339eb61ffb19":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_c95dbc83e3a63d6da70a74867dcf9727":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_70a40745b44eeac1f59df327c2070e48":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_76762158b41d0a7c8eaecbf9a16d3983":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_6a20034a05f48b851914578d4d4e829b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_888b6d21e3e3f16e7e3fd92b5ca8e01f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_85f2b2b7c0fec29d56840cebc060574e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_16a3193e2024e7f06bf3ddbe6afd2b43":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_4c47576441b42410b922987e1aef4dab":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_cee412bcabe1b1d9f41c5e486abd4e85":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_2b5e35d4a97f3e0bee3bb0dffd29c50f":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_46de0ad5744aba0a28b04bf15a803c39":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_977b90a6fb8e7f37ae43cd20cd918cc9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9d3479c8fb52867060523f2bd80ac126":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_c8c8eacd5475c173d8bba4b7d74efa6d":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_108ff824fd71c292d6571d452e37d745":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_fb21a30ad4b920faa285dd563b873383":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_220e473ab0e2584aaf68e6575986d67b":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_a2988caa2b3c1aec630570674bb594c1":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_9e36df99118fce4e913534df117013f9":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_3d169557b8089f60f0bc76cf00869f7e":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_75122314003960e82051769f7f0d8547":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_b0f45d679478b431e5fe9203b59e5e81":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_8339c572ad7b20082abe93299f01b817":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_33a6790cc5af6d94a1af2ca1a1bd4876":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_198913d5173b779bb427062f43ad8868":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_blurb_89f4302d819161bef75e2999a3ad4d50":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_cc43e576b2891948f07b4a4e0202d3dc":{"bosh":true,"pos":true,"anim":true},"et_pb_blurb_c77d6d2f7e02ad7169f1688315680bea":{"glde":{"header_font_size":"18","header_letter_spacing":"0px","header_line_height":"1em","body_font_size":"14","body_letter_spacing":"0px","body_line_height":"1.7em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_31b7219c6b509a6f983a3e6918b21869":{"bosh":true,"pos":true,"anim":true},"et_pb_section_cb73de890a51d8c4c360798d5dcf591f":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_8e0b9d3f3d258b136abcb15eac117d4f":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b0fc2c52738bf8c52d74158a96793c29":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_3b7edbd6535756c250fa13a44e97fb54":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_ce7a024e6e3348b8ad743cd83254c0c2":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_370a804f372560bbf5d8808d84797528":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_355a185fa30bb08ea5e16e4109f3e52e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f734d9bbe4a455c0fbd40c6ace77aba1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_254049e72da468fb1d5df71ad77d8fa1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a5e7c41b98d9fa4a1de95e1c5f8a19a1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0f1d58f1d8a82604a685c2ff332ad962":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_64ed918eac00cafeba4c6dee51ac44a3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_056546f937824831dc0941827f0802cd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_2883e10aa671f36045c4711c0d5550f3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_0c6d307b4140e4a1f2890b6644b08a42":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_393d499bd1cf767049902a201e01b6df":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f3dcdd392088066b6770a744f8e13f4":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_64a504314cc634c4d3d763fc2d293655":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_ed8e140de3577b3f2459d73880de5fc5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_5a207de27e0752125609cb9346c8ef7f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_60ec34497e6dd15d202d270eff4cc4a2":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_a7cdd5f0dc08cd2c14245e8d2d5099c9":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_6e0fba2cf608b4ad1c06c25ba79241b0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_3e7cfc41042fbb0a3e38730e91758c9c":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_06ff67bf62101f55baa920a7811d5a3d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_1071344048027ad93607455606f56e43":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9bb2686d54fc0cb27bdd190f342e49f1":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ff2fda3ad65195e7a48ebbd33f02e411":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_926915f01c59231473997dd9cfe8e7cf":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_a64ab29ada2c6f21ceaeceaebe4286aa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a81f5ba9e8c18b56e910512764f5e4c4":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1a3f67adef4aa6d9a16ccd98e9aa1d2a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_f50cf8f4436757e67b743fa23268d1f1":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_f3a67b0f6b8f65a14c8fa6be6a2e2384":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4d1a336505729a06e3f973fafcea54ea":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_3f0fce30a74acf0475a1240d8b721cc0":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_81d6c026853a0c14465e7aa33c83cee9":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_eb9c5d723b327f23b4503f363f8c01c6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_5839bdfef6eb01c40fd7eb28c91f8b76":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_c4226bc7119dad3a431f9e3e9a4068e7":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_a79153d7ae7b080aca4fb75beab390b3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_b7fbe7594654b4e39f29781a316adc98":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_85075cedb384483a421dabc52d1d7de5":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d27d133f0154902764c6ac450f7bc35e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_7f0a603eadda2bb25066762bf07f2142":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_37705beba071b901564fb798fd718745":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_2065faaafe9f2390cd65b3b0c97fd183":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_d454176ef16b3a30aefb71af4b8c1ec6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_9af7d964f8f2de528e4fac08e6924baa":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_4a05a17bb0504c5cd1cacca1d674db05":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_220c4d5e8f37bc9b0c4035dedbbebb7a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_6aef04c39a068301c7c87908c550b097":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_d7688747de5ede0b104897d7e5ff431a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_9e8c920121e290e78a831801380a1d9e":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_a071358de769b683d941974803ce07d3":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_33f7b40f7c3c3a952ce26076f37a9399":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_106e009dae8421f42581ff8e79b78dbc":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_487f98463f303b49a3dc6a98c7dcca38":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_de70cb9a1e9d68457ac578512ff6a551":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_e0e54bdbcebb3a8f09e13e444cb88d9f":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_9b1bf1bef98405149791594f14d56cd6":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_2c6902a55cf48173bd5242a23275453a":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_section_ca98dc181feae921d6150627f60c5942":{"bor":true,"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_text_1738130b3f4648bc4707b79748b3435d":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"mawi":true,"bosh":true,"pos":true,"anim":true},"et_pb_text_104c37f6c71c02fff00a1c281f8e3d22":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"bor":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_section_90e39bd4662ccd4cc6eb3ba7817ba5e7":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_row_5f81ea5651011a99f04c74616025217d":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_75c3da534472b7f5274f30e4e06b19c0":{"bosh":true,"pos":true,"anim":true},"et_pb_image_7ae84767bd2ed63a3aeeecdd5fb6821c":{"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_column_07fd7228a0823a62d6b7d78e750a3437":{"bosh":true,"pos":true,"anim":true},"et_pb_text_1a004deb34f49e2d716beb8ee19ab6fd":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_row_7adf714a68c325ccb0a003d943a50666":{"cuma":true,"mawi":true,"bosh":true,"mapac":true,"anim":true},"et_pb_column_73b9eb5fd901ca4f92ba33c720d13c5b":{"bosh":true,"pos":true,"anim":true},"et_pb_text_061ada0f9aa2e0252cb63d64e4976df6":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true},"et_pb_text_34ba73541306f4258b86c54ff3f5a308":{"glde":{"text_font_size":"14","text_letter_spacing":"0px","text_line_height":"1.7em","header_font_size":"30px","header_letter_spacing":"0px","header_line_height":"1em","background_size":"cover","background_position":"center","background_repeat":"no-repeat","background_blend":"normal"},"foop":true,"tesh":true,"cuma":true,"mawi":true,"bosh":true,"pos":true,"mapac":true,"anim":true}}],"taxonomy=language":"Portugu\u00eas","taxonomy=post_translations":"","taxonomy=regiao":"Centro-Sul | Subtropical","taxonomy=tema":"Abastecimento e Acesso a Alimentos, Agricultura Local, Alimenta\u00e7\u00e3o Escolar, Governan\u00e7a e Marcos Legais, Incentivo Fiscal, Nutri\u00e7\u00e3o e Vulnerabilidades, Resili\u00eancia Clim\u00e1tica e Circularidade"},"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"},"id":379,"custom_filters":{"%regiao%":["Centro-Sul | Subtropical"],"%tema%":["Abastecimento e Acesso a Alimentos","Agricultura Local","Alimenta\u00e7\u00e3o Escolar","Governan\u00e7a e Marcos Legais","Incentivo Fiscal","Nutri\u00e7\u00e3o e Vulnerabilidades","Resili\u00eancia Clim\u00e1tica e Circularidade"]},"infowindow_disable":false,"categories":[{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"LOSAN (Lei Org\u00e2nica de Seguran\u00e7a Alimentar e Nutricional)","id":"4","type":"category","extension_fields":{"cat_order":"1"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"COMSEA (Conselho Municipal de Seguran\u00e7a Alimentar e Nutricional)","id":"5","type":"category","extension_fields":{"cat_order":"2"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"SISAN (Sistema Nacional de Seguran\u00e7a Alimentar e Nutricional)","id":"6","type":"category","extension_fields":{"cat_order":"3"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Confer\u00eancia municipal de seguran\u00e7a alimentar e nutricional","id":"7","type":"category","extension_fields":{"cat_order":"4"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Frente Parlamentar de SAN","id":"9","type":"category","extension_fields":{"cat_order":"6"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de SAN","id":"10","type":"category","extension_fields":{"cat_order":"7"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Dados de Obesidade e Sobrepeso","id":"12","type":"category","extension_fields":{"cat_order":"9"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras convencionais","id":"19","type":"category","extension_fields":{"cat_order":"16"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Feiras agroecologicas ou org\u00e2nicas","id":"20","type":"category","extension_fields":{"cat_order":"15"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mercados/ Central de Abastecimento","id":"22","type":"category","extension_fields":{"cat_order":"19"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Zona rural no Plano Diretor","id":"24","type":"category","extension_fields":{"cat_order":"21"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Mapeamento de produtores familiares","id":"25","type":"category","extension_fields":{"cat_order":"22"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Conselho de desenvolvimento rural sustent\u00e1vel","id":"26","type":"category","extension_fields":{"cat_order":"23"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Lei de incentivo \u00e0 agricultura urbana","id":"27","type":"category","extension_fields":{"cat_order":"24"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de hortas escolares","id":"28","type":"category","extension_fields":{"cat_order":"25"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivo \u00e0 transi\u00e7\u00e3o agroecol\u00f3gica","id":"30","type":"category","extension_fields":{"cat_order":"27"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Banco de sementes crioulas e mudas org\u00e2nicas","id":"31","type":"category","extension_fields":{"cat_order":"28"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Central de beneficiamento de alimentos","id":"32","type":"category","extension_fields":{"cat_order":"29"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Capacita\u00e7\u00e3o de merendeiras","id":"37","type":"category","extension_fields":{"cat_order":"34"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Compra direta da agricultura familiar na alimenta\u00e7\u00e3o escolar","id":"38","type":"category","extension_fields":{"cat_order":"35"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Org\u00e2nicos/ agroecol\u00f3gicos na alimenta\u00e7\u00e3o escolar","id":"39","type":"category","extension_fields":{"cat_order":"36"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Plano de Resili\u00eancia - ou de A\u00e7\u00e3o - Clim\u00e1tica","id":"40","type":"category","extension_fields":{"cat_order":"37"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Invent\u00e1rio de emiss\u00f5es de gases de efeito estufa","id":"42","type":"category","extension_fields":{"cat_order":"39"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Controle de desmatamento","id":"45","type":"category","extension_fields":{"cat_order":"42"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Programa de compostagem","id":"46","type":"category","extension_fields":{"cat_order":"43"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Coleta seletiva","id":"47","type":"category","extension_fields":{"cat_order":"44"}},{"icon":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","name":"Incentivos fiscais","id":"48","type":"category","extension_fields":{"cat_order":"45"}}]}],"listing":{"listing_header":"Filtrar locais por categoria","display_search_form":true,"search_field_autosuggest":false,"display_category_filter":true,"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_listing1","tabs_container":".location_listing1","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</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;/div&gt;"}},"map_property":{"map_id":"1","debug_mode":false},"map_marker_spiderfier_setting":{"minimum_markers":"0"},"shapes":{"drawing_editable":false},"filters":{"custom_filters":{"filters":{"dropdown":{"%tema%":"Selecione o tema","%regiao%":"Selecione a Regi\u00e3o"}}},"filters_container":"[data-container=\"wpgmp-filters-container\"]"},"marker_category_icons":{"4":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","5":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","6":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","7":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","8":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","9":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","10":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","11":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","12":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","14":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","15":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","16":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","17":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","18":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","19":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","20":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","21":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","22":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","23":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","24":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","25":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","26":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","27":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","28":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","29":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","30":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","31":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","32":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","33":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","34":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","35":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","36":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","37":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","38":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","39":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","40":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","41":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","42":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","43":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","44":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","45":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","46":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","47":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png","48":"https://luppa.comidadoamanha.org/wp-content/plugins/wp-google-map-gold/assets/images/icons/21-generic.png"}}