On Toffia’s Lauretana Square is the convent complex of St. Bernardine of Siena, located in the ancient “castrum Tophiae” in the upper part of the village (Montecavallo and Castel di dentro). This complex includes a church and service rooms
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