
<p style="text-align: center;"><strong>Comunicado del Movimiento Cultural Cristiano</strong></p>
<p style="text-align: center;"><strong>Navidad 2024</strong></p>

<h2 style="text-align: center;">La guerra es un fracaso de la humanidad, la paz un deseo de los más empobrecidos.</h2>
<h3><strong>Esta economía capitalista está desbocada contra los más débiles y empobrecidos. Este capitalismo ya ha conseguido que el 1% de la población mundial atesore más riquezas que el 95% del resto de la población junta. Se podría decir sin equivocarnos que es una economía de guerra contra la mayoría de la población. Una economía que mata en muchos frentes y mata en muchos sentidos.</strong></h3>
<p style="text-align: center;"><a href="https://descargas.solidaridad.net/descargas/comunicado-de-navidad-2024/?tmstv=1732528185" target="_blank" rel="noopener"><strong>DESCARGA EL COMUNICADO EN PDF</strong></a></p>
<strong>Mata con la guerra del hambre</strong>. Las rentas del capital no han parado de crecer mientras que la inmensa mayoría de las familias en el mundo tienen que vivir con un trabajo pagado con salarios de miseria. Un salario con el que no pueden acceder a la compra de los productos más básicos, es decir, pasando hambre. En un mundo inmensamente rico, sigue muriendo de hambre una persona cada 5 segundos. Y lo paradójico es que todos los productos de ocio, evasión y entretenimiento son cada vez más baratos. Está claro que nos quieren embrutecidos, corrompidos y políticamente anestesiados.<img class="size-medium wp-image-31029 alignright" src="https://solidaridad.net/wp-content/uploads/2015/09/Cartel-niña-2015-214x300-214x300.jpg" alt="" width="214" height="300" />

<strong>Mata con el robo financiero y la deuda</strong>. Ese 1% de la población más rica controla también cerca del 50% de todos los fondos financieros. Toda inversión sale rentable cuando consigue que todos, desde las empresas a las familias, estemos endeudados y esclavizados con sus créditos. Y esta deuda deja a los Estados más débiles y a las familias más débiles sin acceso a los servicios más elementales para vivir con dignidad: sin acceso a la vivienda, al trabajo, a la educación o a la sanidad.

<strong>Mata con la esclavitud laboral de los adultos y de los niños.</strong> Más del 60% de la población mundial está viviendo en la economía informal, sin contratos laborales ni prestaciones sociales. Sigue habiendo cerca de 400 millones de niños esclavos. La mayoría de la población sobrevive en una economía de supervivencia precaria. Y en grandísima parte, en una economía de productos y servicios que destruyen a las personas. Es la economía de las drogas, el tráfico y la trata de personas o la pornografía. <strong>Mata cuando se elimina la vida naciente y la vida de los considerados “no- útiles”</strong> (ya sean ancianos, enfermos crónicos o discapacitados). Hoy se producen cerca de 80 millones de abortos en un solo año y esta cifra no deja de aumentar. Una matanza que ya ha exigido legalizarse. <strong>Mata con la devastación del medioambiente natural</strong>, que es también una guerra contra los más empobrecidos. Porque el ambiente natural y el ambiente humano se degradan juntos. El capitalismo necesita ahora disfrazarse de “verde” y “sostenible” … pero ocultando que los minerales necesarios para esta transición energética están siendo extraídos a precio de saldo en los países empobrecidos del Sur. Este saqueo de tierras está produciendo conflictos armados y destrucción salvaje del medio ambiente.

<strong>Mata con los conflictos y las guerras armadas</strong>. La venta de armas<a href="https://solidaridad.net/estaeconomiamata/?td_action=tdc_edit&amp;post_id=45929&amp;tdbTemplateType=page#_ftn1" name="_ftnref1">[1]</a> es un gran negocio. Ucrania y Gaza son sólo exponentes muy significativos de los más de 52 conflictos armados que existen. Hay guerras cronificadas en Sudán, en el Congo, en Yemen o en gran parte de Iberoamérica, donde la violencia se ha convertido en rutina sangrienta para las familias empobrecidas. Se trata de conflictos armados dónde los niños son los que más sufren las consecuencias. Uno de cada cinco menores en todo el mundo (aproximadamente 420 millones) sólo conocen la guerra. La infancia de estos niños, de una generación completa en muchas áreas del mundo, quedará marcada indeleblemente por una violencia y una destrucción que ningún niño debería ver jamás. <strong>Pero lo peor es que estamos aceptando un clima de miedo y desesperación</strong> en el que se nos hace creer que no se pueden abrir auténticos caminos de Paz, que la solución vendrá de los poderosos y de la violencia, de la Inteligencia artificial y de las armas, de levantar muros que nos dividen y supuestamente nos protegen, o de narcotizarnos con más y más evasiones o drogas.<img class="alignright wp-image-66052" src="https://solidaridad.net/wp-content/uploads/2024/10/PORTADA-AG-155-A4-v2-1-212x300.jpg" sizes="(max-width: 300px) 100vw, 300px" srcset="https://solidaridad.net/wp-content/uploads/2024/10/PORTADA-AG-155-A4-v2-1-212x300.jpg 212w, https://solidaridad.net/wp-content/uploads/2024/10/PORTADA-AG-155-A4-v2-1-724x1024.jpg 724w, https://solidaridad.net/wp-content/uploads/2024/10/PORTADA-AG-155-A4-v2-1-768x1087.jpg 768w, https://solidaridad.net/wp-content/uploads/2024/10/PORTADA-AG-155-A4-v2-1-696x985.jpg 696w, https://solidaridad.net/wp-content/uploads/2024/10/PORTADA-AG-155-A4-v2-1-297x420.jpg 297w, https://solidaridad.net/wp-content/uploads/2024/10/PORTADA-AG-155-A4-v2-1.jpg 1000w" alt="" width="300" height="425" /> En estos meses se ha gritado, desde las entrañas, que <strong>sólo el pueblo salva al pueblo</strong>, utilizando un verso de Machado. He aquí un camino auténtico para construir la Paz: aprender a ser un pueblo solidario y fraterno. Esto es algo que la politiquería, envileciendo la política, nunca ha querido hacer. Hay que empezar respetando la dignidad sagrada de todas y cada una de las personas que formamos el pueblo, más allá de banderas y fronteras. Y para continuar, aprendiendo a convivir y organizarnos desde abajo, autogestionariamente, asumiendo cada uno sus propias responsabilidades y poniendo al servicio de los demás las muchísimas capacidades que todos tenemos para construir el Bien Común. No hay pueblo si aceptamos el individualismo, el sálvese quien pueda, el primero lo mío y los míos y luego ya veremos, el afán de lucro y de dinero fácil, el asistencialismo y el embrutecimiento que nos degrada como personas, la indiferencia y la ausencia de compromiso. La Paz se construye desde abajo, educándonos y viviéndola en la familia, en las comunidades de vecinos, en los barrios, en los municipios, en el trabajo. Te invitamos a una reflexión sobre el modelo de sociedad que estamos construyendo todos y cada uno de nosotros. <img class=" wp-image-15850 alignright" src="https://solidaridad.net/wp-content/uploads/2015/11/LogoMCC.jpg" sizes="(max-width: 143px) 100vw, 143px" srcset="https://solidaridad.net/wp-content/uploads/2015/11/LogoMCC.jpg 248w, https://solidaridad.net/wp-content/uploads/2015/11/LogoMCC-100x70.jpg 100w" alt="" width="143" height="102" />

El Movimiento Cultural Cristiano, en estos actos solidarios que celebramos en España e Iberoamérica estas navidades, queremos decir <strong>Si a un modelo y una propuesta de Paz de un niño que nació en un pesebre y murió adulto condenado a muerte en una Cruz, siendo inocente</strong>. <strong>Decir “si” al que muchos han llamado “el Príncipe de la Paz”, significa decir «no» a la guerra, a la misma lógica de la guerra, un viaje sin meta, una derrota sin vencedores, una locura sin excusas…</strong> El pesebre pobre que hoy representamos en la calle, quiere poner de manifiesto las verdaderas riquezas de la vida, que no son el dinero y el poder; sino la justicia, la solidaridad y la paz. El pesebre nos muestra el camino de la vida asociada, la vida solidaria en medio de un mundo en guerra. Esta es la Esperanza.

MOVIMIENTO CULTURAL CRISTIANO

Infórmate de nuestra agenda de actos estas navidades en <a href="http://solidaridad.net">solidaridad.net</a>

Más información sobre nuestras marchas y concentraciones en la agenda en solidaridad.net#EstaEconomiaMata #TodosResponsablesdeTodos #JusticiaNorteSur

Síguenos en la red X @Solidaridadnet
