Santa Susanna, situata a Rieti, è una delle aree naturali più suggestive e interessanti del Lazio. Questa sorgente è famosa non solo per la sua bellezza paesaggistica, ma anche per il suo valore storico.

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