-
To vaksinerte beboere coronasmittet
-
DNT-hytte stenges
-
Innrømmer å ha tent på gjest
-
Melding om slagsmål på trikk
-
Nedjusterer risikovinået i Storbritannia
-
Bekreftet britisk mutantsmitte i Hemsedal
-
- Har fått Trump-dokumenter
-
Mann i 30-åra var på jobb da han ble tatt av skred
-
Starter arbeidet med mutant-vaksine
-
Johansen utelukker ikke innstramminger

Ny pille: 15 prosentvektreduksjon

Tror knaptsine egne ører
Annonsørinnhold


10 tips for åstumpe røyken
i samarbeid medOverlege: Effektivbehandling mot dette

30 år gammelcyste: - Herregud!
Annonsørinnhold


Namsosing blemillionær på loftet!
i samarbeid med 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
Last ned appen vår
Vi bryr oss om ditt personvern
dagbladet er en del av Aller Media, som er ansvarlig for dine data. Vi bruker dataene til å forbedre og tilpasse tjenestene, tilbudene og annonsene våre.