Arhiv kategorij: Krožne ture

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