From Poggio Catino, a small hamlet nestled in the hills of Sabina, you can enjoy breathtaking views encompassing the entire Tiber Valley, with its picturesque landscapes, green fields and lush forests stretching as far as the eye can see.
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